-
-struct _sqlite3StmtRuby {
- sqlite3_stmt *st;
- int done_p;
-};
-
-typedef struct _sqlite3StmtRuby sqlite3StmtRuby;
-typedef sqlite3StmtRuby * sqlite3StmtRubyPtr;
-
-void init_sqlite3_statement();
-
-#endif
diff --git a/vendor/plugins/sqlite3-ruby/faq/faq.rb b/vendor/plugins/sqlite3-ruby/faq/faq.rb
deleted file mode 100644
index 61d7d01c..00000000
--- a/vendor/plugins/sqlite3-ruby/faq/faq.rb
+++ /dev/null
@@ -1,145 +0,0 @@
-require 'yaml'
-require 'redcloth'
-
-def process_faq_list( faqs )
- puts ""
- faqs.each do |faq|
- process_faq_list_item faq
- end
- puts "
"
-end
-
-def process_faq_list_item( faq )
- question = faq.keys.first
- answer = faq.values.first
-
- print ""
-
- question_text = RedCloth.new(question).to_html.gsub( %r{},"" )
- if answer.is_a?( Array )
- puts question_text
- process_faq_list answer
- else
- print "#{question_text}"
- end
-
- puts ""
-end
-
-def process_faq_descriptions( faqs, path=nil )
- faqs.each do |faq|
- process_faq_description faq, path
- end
-end
-
-def process_faq_description( faq, path )
- question = faq.keys.first
- path = ( path ? path + " " : "" ) + question
- answer = faq.values.first
-
- if answer.is_a?( Array )
- process_faq_descriptions( answer, path )
- else
- title = RedCloth.new( path ).to_html.gsub( %r{}, "" )
- answer = RedCloth.new( answer || "" )
-
- puts ""
- puts "#{title}
"
- puts "#{add_api_links(answer.to_html)}
"
- end
-end
-
-API_OBJECTS = [ "Database", "Statement", "ResultSet",
- "ParsedStatement", "Pragmas", "Translator" ].inject( "(" ) { |acc,name|
- acc << "|" if acc.length > 1
- acc << name
- acc
- } + ")"
-
-def add_api_links( text )
- text.gsub( /#{API_OBJECTS}(#(\w+))?/ ) do
- disp_obj = obj = $1
-
- case obj
- when "Pragmas"; disp_obj = "Database"
- end
-
- method = $3
- s = "#{disp_obj}"
- s << "##{method}" if method
- s << ""
- s
- end
-end
-
-faqs = YAML.load( File.read( "faq.yml" ) )
-
-puts <<-EOF
-
-
- SQLite3/Ruby FAQ
-
-
-
- SQLite/Ruby FAQ
-
-EOF
-
-process_faq_list( faqs )
-puts "
"
-process_faq_descriptions( faqs )
-
-puts ""
diff --git a/vendor/plugins/sqlite3-ruby/faq/faq.yml b/vendor/plugins/sqlite3-ruby/faq/faq.yml
deleted file mode 100644
index f4bb4c1b..00000000
--- a/vendor/plugins/sqlite3-ruby/faq/faq.yml
+++ /dev/null
@@ -1,426 +0,0 @@
----
-- "How do I do a database query?":
- - "I just want an array of the rows...": >-
-
- Use the Database#execute method. If you don't give it a block, it will
- return an array of all the rows:
-
-
-
- require 'sqlite3'
-
- db = SQLite3::Database.new( "test.db" )
- rows = db.execute( "select * from test" )
-
-
- - "I'd like to use a block to iterate through the rows...": >-
-
- Use the Database#execute method. If you give it a block, each row of the
- result will be yielded to the block:
-
-
-
- require 'sqlite3'
-
- db = SQLite3::Database.new( "test.db" )
- db.execute( "select * from test" ) do |row|
- ...
- end
-
-
- - "I need to get the column names as well as the rows...": >-
-
- Use the Database#execute2 method. This works just like Database#execute;
- if you don't give it a block, it returns an array of rows; otherwise, it
- will yield each row to the block. _However_, the first row returned is
- always an array of the column names from the query:
-
-
-
- require 'sqlite3'
-
- db = SQLite3::Database.new( "test.db" )
- columns, *rows = db.execute2( "select * from test" )
-
- # or use a block:
-
- columns = nil
- db.execute2( "select * from test" ) do |row|
- if columns.nil?
- columns = row
- else
- # process row
- end
- end
-
-
- - "I just want the first row of the result set...": >-
-
- Easy. Just call Database#get_first_row:
-
-
-
- row = db.get_first_row( "select * from table" )
-
-
-
- This also supports bind variables, just like Database#execute
- and friends.
-
- - "I just want the first value of the first row of the result set...": >-
-
- Also easy. Just call Database#get_first_value:
-
-
-
- count = db.get_first_value( "select count(*) from table" )
-
-
-
- This also supports bind variables, just like Database#execute
- and friends.
-
-- "How do I prepare a statement for repeated execution?": >-
- If the same statement is going to be executed repeatedly, you can speed
- things up a bit by _preparing_ the statement. You do this via the
- Database#prepare method. It returns a Statement object, and you can
- then invoke #execute on that to get the ResultSet:
-
-
-
- stmt = db.prepare( "select * from person" )
-
- 1000.times do
- stmt.execute do |result|
- ...
- end
- end
-
- stmt.close
-
- # or, use a block
-
- db.prepare( "select * from person" ) do |stmt|
- 1000.times do
- stmt.execute do |result|
- ...
- end
- end
- end
-
-
-
- This is made more useful by the ability to bind variables to placeholders
- via the Statement#bind_param and Statement#bind_params methods. (See the
- next FAQ for details.)
-
-- "How do I use placeholders in an SQL statement?": >-
- Placeholders in an SQL statement take any of the following formats:
-
-
- * @?@
-
- * @?_nnn_@
-
- * @:_word_@
-
-
- Where _n_ is an integer, and _word_ is an alpha-numeric identifier (or
- number). When the placeholder is associated with a number, that number
- identifies the index of the bind variable to replace it with. When it
- is an identifier, it identifies the name of the correponding bind
- variable. (In the instance of the first format--a single question
- mark--the placeholder is assigned a number one greater than the last
- index used, or 1 if it is the first.)
-
-
- For example, here is a query using these placeholder formats:
-
-
-
- select *
- from table
- where ( c = ?2 or c = ? )
- and d = :name
- and e = :1
-
-
-
- This defines 5 different placeholders: 1, 2, 3, and "name".
-
-
- You replace these placeholders by _binding_ them to values. This can be
- accomplished in a variety of ways.
-
-
- The Database#execute, and Database#execute2 methods all accept additional
- arguments following the SQL statement. These arguments are assumed to be
- bind parameters, and they are bound (positionally) to their corresponding
- placeholders:
-
-
-
- db.execute( "select * from table where a = ? and b = ?",
- "hello",
- "world" )
-
-
-
- The above would replace the first question mark with 'hello' and the
- second with 'world'. If the placeholders have an explicit index given, they
- will be replaced with the bind parameter at that index (1-based).
-
-
- If a Hash is given as a bind parameter, then its key/value pairs are bound
- to the placeholders. This is how you bind by name:
-
-
-
- db.execute( "select * from table where a = :name and b = :value",
- "name" => "bob",
- "value" => "priceless" )
-
-
-
- You can also bind explicitly using the Statement object itself. Just pass
- additional parameters to the Statement#execute statement:
-
-
-
- db.prepare( "select * from table where a = :name and b = ?" ) do |stmt|
- stmt.execute "value", "name" => "bob"
- end
-
-
-
- Or do a Database#prepare to get the Statement, and then use either
- Statement#bind_param or Statement#bind_params:
-
-
-
- stmt = db.prepare( "select * from table where a = :name and b = ?" )
-
- stmt.bind_param( "name", "bob" )
- stmt.bind_param( 1, "value" )
-
- # or
-
- stmt.bind_params( "value", "name" => "bob" )
-
-
-- "How do I discover metadata about a query?": >-
-
- If you ever want to know the names or types of the columns in a result
- set, you can do it in several ways.
-
-
- The first way is to ask the row object itself. Each row will have a
- property "fields" that returns an array of the column names. The row
- will also have a property "types" that returns an array of the column
- types:
-
-
-
- rows = db.execute( "select * from table" )
- p rows[0].fields
- p rows[0].types
-
-
-
- Obviously, this approach requires you to execute a statement that actually
- returns data. If you don't know if the statement will return any rows, but
- you still need the metadata, you can use Database#query and ask the
- ResultSet object itself:
-
-
-
- db.query( "select * from table" ) do |result|
- p result.columns
- p result.types
- ...
- end
-
-
-
- Lastly, you can use Database#prepare and ask the Statement object what
- the metadata are:
-
-
-
- stmt = db.prepare( "select * from table" )
- p stmt.columns
- p stmt.types
-
-
-- "I'd like the rows to be indexible by column name.": >-
- By default, each row from a query is returned as an Array of values. This
- means that you can only obtain values by their index. Sometimes, however,
- you would like to obtain values by their column name.
-
-
- The first way to do this is to set the Database property "results_as_hash"
- to true. If you do this, then all rows will be returned as Hash objects,
- with the column names as the keys. (In this case, the "fields" property
- is unavailable on the row, although the "types" property remains.)
-
-
-
- db.results_as_hash = true
- db.execute( "select * from table" ) do |row|
- p row['column1']
- p row['column2']
- end
-
-
-
- The other way is to use Ara Howard's
- "ArrayFields":http://rubyforge.org/projects/arrayfields
- module. Just require "arrayfields", and all of your rows will be indexable
- by column name, even though they are still arrays!
-
-
-
- require 'arrayfields'
-
- ...
- db.execute( "select * from table" ) do |row|
- p row[0] == row['column1']
- p row[1] == row['column2']
- end
-
-
-- "I'd like the values from a query to be the correct types, instead of String.": >-
- You can turn on "type translation" by setting Database#type_translation to
- true:
-
-
-
- db.type_translation = true
- db.execute( "select * from table" ) do |row|
- p row
- end
-
-
-
- By doing this, each return value for each row will be translated to its
- correct type, based on its declared column type.
-
-
- You can even declare your own translation routines, if (for example) you are
- using an SQL type that is not handled by default:
-
-
-
- # assume "objects" table has the following schema:
- # create table objects (
- # name varchar2(20),
- # thing object
- # )
-
- db.type_translation = true
- db.translator.add_translator( "object" ) do |type, value|
- db.decode( value )
- end
-
- h = { :one=>:two, "three"=>"four", 5=>6 }
- dump = db.encode( h )
-
- db.execute( "insert into objects values ( ?, ? )", "bob", dump )
-
- obj = db.get_first_value( "select thing from objects where name='bob'" )
- p obj == h
-
-
-- "How do insert binary data into the database?": >-
- Use blobs. Blobs are new features of SQLite3. You have to use bind
- variables to make it work:
-
-
-
- db.execute( "insert into foo ( ?, ? )",
- SQLite3::Blob.new( "\0\1\2\3\4\5" ),
- SQLite3::Blob.new( "a\0b\0c\0d ) )
-
-
-
- The blob values must be indicated explicitly by binding each parameter to
- a value of type SQLite3::Blob.
-
-- "How do I do a DDL (insert, update, delete) statement?": >-
- You can actually do inserts, updates, and deletes in exactly the same way
- as selects, but in general the Database#execute method will be most
- convenient:
-
-
-
- db.execute( "insert into table values ( ?, ? )", *bind_vars )
-
-
-- "How do I execute multiple statements in a single string?": >-
- The standard query methods (Database#execute, Database#execute2,
- Database#query, and Statement#execute) will only execute the first
- statement in the string that is given to them. Thus, if you have a
- string with multiple SQL statements, each separated by a string,
- you can't use those methods to execute them all at once.
-
-
- Instead, use Database#execute_batch:
-
-
-
- sql = <
-
-
- Unlike the other query methods, Database#execute_batch accepts no
- block. It will also only ever return +nil+. Thus, it is really only
- suitable for batch processing of DDL statements.
-
-- "How do I begin/end a transaction?":
- Use Database#transaction to start a transaction. If you give it a block,
- the block will be automatically committed at the end of the block,
- unless an exception was raised, in which case the transaction will be
- rolled back. (Never explicitly call Database#commit or Database#rollback
- inside of a transaction block--you'll get errors when the block
- terminates!)
-
-
-
- database.transaction do |db|
- db.execute( "insert into table values ( 'a', 'b', 'c' )" )
- ...
- end
-
-
-
- Alternatively, if you don't give a block to Database#transaction, the
- transaction remains open until you explicitly call Database#commit or
- Database#rollback.
-
-
-
- db.transaction
- db.execute( "insert into table values ( 'a', 'b', 'c' )" )
- db.commit
-
-
-
- Note that SQLite does not allow nested transactions, so you'll get errors
- if you try to open a new transaction while one is already active. Use
- Database#transaction_active? to determine whether a transaction is
- active or not.
-
-#- "How do I discover metadata about a table/index?":
-#
-#- "How do I do tweak database settings?":
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3.rb
deleted file mode 100644
index b17ce52d..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# support multiple ruby version (fat binaries under windows)
-begin
- RUBY_VERSION =~ /(\d+.\d+)/
- require "sqlite3/#{$1}/sqlite3_native"
-rescue LoadError
- require 'sqlite3/sqlite3_native'
-end
-
-require 'sqlite3/database'
-require 'sqlite3/version'
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/constants.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/constants.rb
deleted file mode 100644
index b316c2d8..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/constants.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-module SQLite3 ; module Constants
-
- module TextRep
- UTF8 = 1
- UTF16LE = 2
- UTF16BE = 3
- UTF16 = 4
- ANY = 5
- end
-
- module ColumnType
- INTEGER = 1
- FLOAT = 2
- TEXT = 3
- BLOB = 4
- NULL = 5
- end
-
- module ErrorCode
- OK = 0 # Successful result
- ERROR = 1 # SQL error or missing database
- INTERNAL = 2 # An internal logic error in SQLite
- PERM = 3 # Access permission denied
- ABORT = 4 # Callback routine requested an abort
- BUSY = 5 # The database file is locked
- LOCKED = 6 # A table in the database is locked
- NOMEM = 7 # A malloc() failed
- READONLY = 8 # Attempt to write a readonly database
- INTERRUPT = 9 # Operation terminated by sqlite_interrupt()
- IOERR = 10 # Some kind of disk I/O error occurred
- CORRUPT = 11 # The database disk image is malformed
- NOTFOUND = 12 # (Internal Only) Table or record not found
- FULL = 13 # Insertion failed because database is full
- CANTOPEN = 14 # Unable to open the database file
- PROTOCOL = 15 # Database lock protocol error
- EMPTY = 16 # (Internal Only) Database table is empty
- SCHEMA = 17 # The database schema changed
- TOOBIG = 18 # Too much data for one row of a table
- CONSTRAINT = 19 # Abort due to contraint violation
- MISMATCH = 20 # Data type mismatch
- MISUSE = 21 # Library used incorrectly
- NOLFS = 22 # Uses OS features not supported on host
- AUTH = 23 # Authorization denied
-
- ROW = 100 # sqlite_step() has another row ready
- DONE = 101 # sqlite_step() has finished executing
- end
-
-end ; end
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb
deleted file mode 100644
index 5a65eecd..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb
+++ /dev/null
@@ -1,570 +0,0 @@
-require 'sqlite3/constants'
-require 'sqlite3/errors'
-require 'sqlite3/pragmas'
-require 'sqlite3/statement'
-require 'sqlite3/translator'
-require 'sqlite3/value'
-
-module SQLite3
-
- # The Database class encapsulates a single connection to a SQLite3 database.
- # Its usage is very straightforward:
- #
- # require 'sqlite3'
- #
- # SQLite3::Database.new( "data.db" ) do |db|
- # db.execute( "select * from table" ) do |row|
- # p row
- # end
- # end
- #
- # It wraps the lower-level methods provides by the selected driver, and
- # includes the Pragmas module for access to various pragma convenience
- # methods.
- #
- # The Database class provides type translation services as well, by which
- # the SQLite3 data types (which are all represented as strings) may be
- # converted into their corresponding types (as defined in the schemas
- # for their tables). This translation only occurs when querying data from
- # the database--insertions and updates are all still typeless.
- #
- # Furthermore, the Database class has been designed to work well with the
- # ArrayFields module from Ara Howard. If you require the ArrayFields
- # module before performing a query, and if you have not enabled results as
- # hashes, then the results will all be indexible by field name.
- class Database
- attr_reader :collations
-
- include Pragmas
-
- class << self
-
- alias :open :new
-
- # Quotes the given string, making it safe to use in an SQL statement.
- # It replaces all instances of the single-quote character with two
- # single-quote characters. The modified string is returned.
- def quote( string )
- string.gsub( /'/, "''" )
- end
-
- end
-
- # A boolean that indicates whether rows in result sets should be returned
- # as hashes or not. By default, rows are returned as arrays.
- attr_accessor :results_as_hash
-
- # A boolean indicating whether or not type translation is enabled for this
- # database.
- attr_accessor :type_translation
-
- # Return the type translator employed by this database instance. Each
- # database instance has its own type translator; this allows for different
- # type handlers to be installed in each instance without affecting other
- # instances. Furthermore, the translators are instantiated lazily, so that
- # if a database does not use type translation, it will not be burdened by
- # the overhead of a useless type translator. (See the Translator class.)
- def translator
- @translator ||= Translator.new
- end
-
- # Installs (or removes) a block that will be invoked for every access
- # to the database. If the block returns 0 (or +nil+), the statement
- # is allowed to proceed. Returning 1 causes an authorization error to
- # occur, and returning 2 causes the access to be silently denied.
- def authorizer( &block )
- self.authorizer = block
- end
-
- # Returns a Statement object representing the given SQL. This does not
- # execute the statement; it merely prepares the statement for execution.
- #
- # The Statement can then be executed using Statement#execute.
- #
- def prepare sql
- stmt = SQLite3::Statement.new( self, sql )
- return stmt unless block_given?
-
- begin
- yield stmt
- ensure
- stmt.close
- end
- end
-
- # Executes the given SQL statement. If additional parameters are given,
- # they are treated as bind variables, and are bound to the placeholders in
- # the query.
- #
- # Note that if any of the values passed to this are hashes, then the
- # key/value pairs are each bound separately, with the key being used as
- # the name of the placeholder to bind the value to.
- #
- # The block is optional. If given, it will be invoked for each row returned
- # by the query. Otherwise, any results are accumulated into an array and
- # returned wholesale.
- #
- # See also #execute2, #query, and #execute_batch for additional ways of
- # executing statements.
- def execute sql, bind_vars = [], *args, &block
- # FIXME: This is a terrible hack and should be removed but is required
- # for older versions of rails
- hack = Object.const_defined?(:ActiveRecord) && sql =~ /^PRAGMA index_list/
-
- if bind_vars.nil? || !args.empty?
- if args.empty?
- bind_vars = []
- else
- bind_vars = [nil] + args
- end
-
- warn(<<-eowarn) if $VERBOSE
-#{caller[0]} is calling SQLite3::Database#execute with nil or multiple bind params
-without using an array. Please switch to passing bind parameters as an array.
- eowarn
- end
-
- prepare( sql ) do |stmt|
- stmt.bind_params(bind_vars)
- if type_translation
- stmt = ResultSet.new(self, stmt).to_a
- end
-
- if block_given?
- stmt.each do |row|
- if @results_as_hash
- h = Hash[*stmt.columns.zip(row).flatten]
- row.each_with_index { |r, i| h[i] = r }
-
- yield h
- else
- yield row
- end
- end
- else
- if @results_as_hash
- stmt.map { |row|
- h = Hash[*stmt.columns.zip(row).flatten]
- row.each_with_index { |r, i| h[i] = r }
-
- # FIXME UGH TERRIBLE HACK!
- h['unique'] = h['unique'].to_s if hack
-
- h
- }
- else
- stmt.to_a
- end
- end
- end
- end
-
- # Executes the given SQL statement, exactly as with #execute. However, the
- # first row returned (either via the block, or in the returned array) is
- # always the names of the columns. Subsequent rows correspond to the data
- # from the result set.
- #
- # Thus, even if the query itself returns no rows, this method will always
- # return at least one row--the names of the columns.
- #
- # See also #execute, #query, and #execute_batch for additional ways of
- # executing statements.
- def execute2( sql, *bind_vars )
- prepare( sql ) do |stmt|
- result = stmt.execute( *bind_vars )
- if block_given?
- yield stmt.columns
- result.each { |row| yield row }
- else
- return result.inject( [ stmt.columns ] ) { |arr,row|
- arr << row; arr }
- end
- end
- end
-
- # Executes all SQL statements in the given string. By contrast, the other
- # means of executing queries will only execute the first statement in the
- # string, ignoring all subsequent statements. This will execute each one
- # in turn. The same bind parameters, if given, will be applied to each
- # statement.
- #
- # This always returns +nil+, making it unsuitable for queries that return
- # rows.
- def execute_batch( sql, bind_vars = [], *args )
- # FIXME: remove this stuff later
- unless [Array, Hash].include?(bind_vars.class)
- bind_vars = [bind_vars]
- warn(<<-eowarn) if $VERBOSE
-#{caller[0]} is calling SQLite3::Database#execute_batch with bind parameters
-that are not a list of a hash. Please switch to passing bind parameters as an
-array or hash.
- eowarn
- end
-
- # FIXME: remove this stuff later
- if bind_vars.nil? || !args.empty?
- if args.empty?
- bind_vars = []
- else
- bind_vars = [nil] + args
- end
-
- warn(<<-eowarn) if $VERBOSE
-#{caller[0]} is calling SQLite3::Database#execute_batch with nil or multiple bind params
-without using an array. Please switch to passing bind parameters as an array.
- eowarn
- end
-
- sql = sql.strip
- until sql.empty? do
- prepare( sql ) do |stmt|
- # FIXME: this should probably use sqlite3's api for batch execution
- # This implementation requires stepping over the results.
- if bind_vars.length == stmt.bind_parameter_count
- stmt.bind_params(bind_vars)
- end
- stmt.step
- sql = stmt.remainder.strip
- end
- end
- nil
- end
-
- # This is a convenience method for creating a statement, binding
- # paramters to it, and calling execute:
- #
- # result = db.query( "select * from foo where a=?", 5 )
- # # is the same as
- # result = db.prepare( "select * from foo where a=?" ).execute( 5 )
- #
- # You must be sure to call +close+ on the ResultSet instance that is
- # returned, or you could have problems with locks on the table. If called
- # with a block, +close+ will be invoked implicitly when the block
- # terminates.
- def query( sql, bind_vars = [], *args )
-
- if bind_vars.nil? || !args.empty?
- if args.empty?
- bind_vars = []
- else
- bind_vars = [nil] + args
- end
-
- warn(<<-eowarn) if $VERBOSE
-#{caller[0]} is calling SQLite3::Database#query with nil or multiple bind params
-without using an array. Please switch to passing bind parameters as an array.
- eowarn
- end
-
- result = prepare( sql ).execute( bind_vars )
- if block_given?
- begin
- yield result
- ensure
- result.close
- end
- else
- return result
- end
- end
-
- # A convenience method for obtaining the first row of a result set, and
- # discarding all others. It is otherwise identical to #execute.
- #
- # See also #get_first_value.
- def get_first_row( sql, *bind_vars )
- execute( sql, *bind_vars ) { |row| return row }
- nil
- end
-
- # A convenience method for obtaining the first value of the first row of a
- # result set, and discarding all other values and rows. It is otherwise
- # identical to #execute.
- #
- # See also #get_first_row.
- def get_first_value( sql, *bind_vars )
- execute( sql, *bind_vars ) { |row| return row[0] }
- nil
- end
-
- alias :busy_timeout :busy_timeout=
-
- # Creates a new function for use in SQL statements. It will be added as
- # +name+, with the given +arity+. (For variable arity functions, use
- # -1 for the arity.)
- #
- # The block should accept at least one parameter--the FunctionProxy
- # instance that wraps this function invocation--and any other
- # arguments it needs (up to its arity).
- #
- # The block does not return a value directly. Instead, it will invoke
- # the FunctionProxy#set_result method on the +func+ parameter and
- # indicate the return value that way.
- #
- # Example:
- #
- # db.create_function( "maim", 1 ) do |func, value|
- # if value.nil?
- # func.result = nil
- # else
- # func.result = value.split(//).sort.join
- # end
- # end
- #
- # puts db.get_first_value( "select maim(name) from table" )
- def create_function name, arity, text_rep=Constants::TextRep::ANY, &block
- define_function(name) do |*args|
- fp = FunctionProxy.new
- block.call(fp, *args)
- fp.result
- end
- self
- end
-
- # Creates a new aggregate function for use in SQL statements. Aggregate
- # functions are functions that apply over every row in the result set,
- # instead of over just a single row. (A very common aggregate function
- # is the "count" function, for determining the number of rows that match
- # a query.)
- #
- # The new function will be added as +name+, with the given +arity+. (For
- # variable arity functions, use -1 for the arity.)
- #
- # The +step+ parameter must be a proc object that accepts as its first
- # parameter a FunctionProxy instance (representing the function
- # invocation), with any subsequent parameters (up to the function's arity).
- # The +step+ callback will be invoked once for each row of the result set.
- #
- # The +finalize+ parameter must be a +proc+ object that accepts only a
- # single parameter, the FunctionProxy instance representing the current
- # function invocation. It should invoke FunctionProxy#set_result to
- # store the result of the function.
- #
- # Example:
- #
- # db.create_aggregate( "lengths", 1 ) do
- # step do |func, value|
- # func[ :total ] ||= 0
- # func[ :total ] += ( value ? value.length : 0 )
- # end
- #
- # finalize do |func|
- # func.set_result( func[ :total ] || 0 )
- # end
- # end
- #
- # puts db.get_first_value( "select lengths(name) from table" )
- #
- # See also #create_aggregate_handler for a more object-oriented approach to
- # aggregate functions.
- def create_aggregate( name, arity, step=nil, finalize=nil,
- text_rep=Constants::TextRep::ANY, &block )
-
- factory = Class.new do
- def self.step( &block )
- define_method(:step, &block)
- end
-
- def self.finalize( &block )
- define_method(:finalize, &block)
- end
- end
-
- if block_given?
- factory.instance_eval(&block)
- else
- factory.class_eval do
- define_method(:step, step)
- define_method(:finalize, finalize)
- end
- end
-
- proxy = factory.new
- proxy.extend(Module.new {
- attr_accessor :ctx
-
- def step( *args )
- super(@ctx, *args)
- end
-
- def finalize
- super(@ctx)
- end
- })
- proxy.ctx = FunctionProxy.new
- define_aggregator(name, proxy)
- end
-
- # This is another approach to creating an aggregate function (see
- # #create_aggregate). Instead of explicitly specifying the name,
- # callbacks, arity, and type, you specify a factory object
- # (the "handler") that knows how to obtain all of that information. The
- # handler should respond to the following messages:
- #
- # +arity+:: corresponds to the +arity+ parameter of #create_aggregate. This
- # message is optional, and if the handler does not respond to it,
- # the function will have an arity of -1.
- # +name+:: this is the name of the function. The handler _must_ implement
- # this message.
- # +new+:: this must be implemented by the handler. It should return a new
- # instance of the object that will handle a specific invocation of
- # the function.
- #
- # The handler instance (the object returned by the +new+ message, described
- # above), must respond to the following messages:
- #
- # +step+:: this is the method that will be called for each step of the
- # aggregate function's evaluation. It should implement the same
- # signature as the +step+ callback for #create_aggregate.
- # +finalize+:: this is the method that will be called to finalize the
- # aggregate function's evaluation. It should implement the
- # same signature as the +finalize+ callback for
- # #create_aggregate.
- #
- # Example:
- #
- # class LengthsAggregateHandler
- # def self.arity; 1; end
- #
- # def initialize
- # @total = 0
- # end
- #
- # def step( ctx, name )
- # @total += ( name ? name.length : 0 )
- # end
- #
- # def finalize( ctx )
- # ctx.set_result( @total )
- # end
- # end
- #
- # db.create_aggregate_handler( LengthsAggregateHandler )
- # puts db.get_first_value( "select lengths(name) from A" )
- def create_aggregate_handler( handler )
- proxy = Class.new do
- def initialize handler
- @handler = handler
- @fp = FunctionProxy.new
- end
-
- def step( *args )
- @handler.step(@fp, *args)
- end
-
- def finalize
- @handler.finalize @fp
- @fp.result
- end
- end
- define_aggregator(handler.name, proxy.new(handler.new))
- self
- end
-
- # Begins a new transaction. Note that nested transactions are not allowed
- # by SQLite, so attempting to nest a transaction will result in a runtime
- # exception.
- #
- # The +mode+ parameter may be either :deferred (the default),
- # :immediate, or :exclusive.
- #
- # If a block is given, the database instance is yielded to it, and the
- # transaction is committed when the block terminates. If the block
- # raises an exception, a rollback will be performed instead. Note that if
- # a block is given, #commit and #rollback should never be called
- # explicitly or you'll get an error when the block terminates.
- #
- # If a block is not given, it is the caller's responsibility to end the
- # transaction explicitly, either by calling #commit, or by calling
- # #rollback.
- def transaction( mode = :deferred )
- execute "begin #{mode.to_s} transaction"
- @transaction_active = true
-
- if block_given?
- abort = false
- begin
- yield self
- rescue ::Object
- abort = true
- raise
- ensure
- abort and rollback or commit
- end
- end
-
- true
- end
-
- # Commits the current transaction. If there is no current transaction,
- # this will cause an error to be raised. This returns +true+, in order
- # to allow it to be used in idioms like
- # abort? and rollback or commit.
- def commit
- execute "commit transaction"
- @transaction_active = false
- true
- end
-
- # Rolls the current transaction back. If there is no current transaction,
- # this will cause an error to be raised. This returns +true+, in order
- # to allow it to be used in idioms like
- # abort? and rollback or commit.
- def rollback
- execute "rollback transaction"
- @transaction_active = false
- true
- end
-
- # Returns +true+ if there is a transaction active, and +false+ otherwise.
- def transaction_active?
- @transaction_active
- end
-
- # A helper class for dealing with custom functions (see #create_function,
- # #create_aggregate, and #create_aggregate_handler). It encapsulates the
- # opaque function object that represents the current invocation. It also
- # provides more convenient access to the API functions that operate on
- # the function object.
- #
- # This class will almost _always_ be instantiated indirectly, by working
- # with the create methods mentioned above.
- class FunctionProxy
- attr_accessor :result
-
- # Create a new FunctionProxy that encapsulates the given +func+ object.
- # If context is non-nil, the functions context will be set to that. If
- # it is non-nil, it must quack like a Hash. If it is nil, then none of
- # the context functions will be available.
- def initialize
- @result = nil
- @context = {}
- end
-
- # Set the result of the function to the given error message.
- # The function will then return that error.
- def set_error( error )
- @driver.result_error( @func, error.to_s, -1 )
- end
-
- # (Only available to aggregate functions.) Returns the number of rows
- # that the aggregate has processed so far. This will include the current
- # row, and so will always return at least 1.
- def count
- @driver.aggregate_count( @func )
- end
-
- # Returns the value with the given key from the context. This is only
- # available to aggregate functions.
- def []( key )
- @context[ key ]
- end
-
- # Sets the value with the given key in the context. This is only
- # available to aggregate functions.
- def []=( key, value )
- @context[ key ] = value
- end
- end
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/errors.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/errors.rb
deleted file mode 100644
index 3936a594..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/errors.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-require 'sqlite3/constants'
-
-module SQLite3
- class Exception < ::StandardError
- @code = 0
-
- # The numeric error code that this exception represents.
- def self.code
- @code
- end
-
- # A convenience for accessing the error code for this exception.
- def code
- self.class.code
- end
- end
-
- class SQLException < Exception; end
- class InternalException < Exception; end
- class PermissionException < Exception; end
- class AbortException < Exception; end
- class BusyException < Exception; end
- class LockedException < Exception; end
- class MemoryException < Exception; end
- class ReadOnlyException < Exception; end
- class InterruptException < Exception; end
- class IOException < Exception; end
- class CorruptException < Exception; end
- class NotFoundException < Exception; end
- class FullException < Exception; end
- class CantOpenException < Exception; end
- class ProtocolException < Exception; end
- class EmptyException < Exception; end
- class SchemaChangedException < Exception; end
- class TooBigException < Exception; end
- class ConstraintException < Exception; end
- class MismatchException < Exception; end
- class MisuseException < Exception; end
- class UnsupportedException < Exception; end
- class AuthorizationException < Exception; end
- class FormatException < Exception; end
- class RangeException < Exception; end
- class NotADatabaseException < Exception; end
-end
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/pragmas.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/pragmas.rb
deleted file mode 100644
index 2e319387..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/pragmas.rb
+++ /dev/null
@@ -1,280 +0,0 @@
-require 'sqlite3/errors'
-
-module SQLite3
-
- # This module is intended for inclusion solely by the Database class. It
- # defines convenience methods for the various pragmas supported by SQLite3.
- #
- # For a detailed description of these pragmas, see the SQLite3 documentation
- # at http://sqlite.org/pragma.html.
- module Pragmas
-
- # Returns +true+ or +false+ depending on the value of the named pragma.
- def get_boolean_pragma( name )
- get_first_value( "PRAGMA #{name}" ) != "0"
- end
- private :get_boolean_pragma
-
- # Sets the given pragma to the given boolean value. The value itself
- # may be +true+ or +false+, or any other commonly used string or
- # integer that represents truth.
- def set_boolean_pragma( name, mode )
- case mode
- when String
- case mode.downcase
- when "on", "yes", "true", "y", "t"; mode = "'ON'"
- when "off", "no", "false", "n", "f"; mode = "'OFF'"
- else
- raise Exception,
- "unrecognized pragma parameter #{mode.inspect}"
- end
- when true, 1
- mode = "ON"
- when false, 0, nil
- mode = "OFF"
- else
- raise Exception,
- "unrecognized pragma parameter #{mode.inspect}"
- end
-
- execute( "PRAGMA #{name}=#{mode}" )
- end
- private :set_boolean_pragma
-
- # Requests the given pragma (and parameters), and if the block is given,
- # each row of the result set will be yielded to it. Otherwise, the results
- # are returned as an array.
- def get_query_pragma( name, *parms, &block ) # :yields: row
- if parms.empty?
- execute( "PRAGMA #{name}", &block )
- else
- args = "'" + parms.join("','") + "'"
- execute( "PRAGMA #{name}( #{args} )", &block )
- end
- end
- private :get_query_pragma
-
- # Return the value of the given pragma.
- def get_enum_pragma( name )
- get_first_value( "PRAGMA #{name}" )
- end
- private :get_enum_pragma
-
- # Set the value of the given pragma to +mode+. The +mode+ parameter must
- # conform to one of the values in the given +enum+ array. Each entry in
- # the array is another array comprised of elements in the enumeration that
- # have duplicate values. See #synchronous, #default_synchronous,
- # #temp_store, and #default_temp_store for usage examples.
- def set_enum_pragma( name, mode, enums )
- match = enums.find { |p| p.find { |i| i.to_s.downcase == mode.to_s.downcase } }
- raise Exception,
- "unrecognized #{name} #{mode.inspect}" unless match
- execute( "PRAGMA #{name}='#{match.first.upcase}'" )
- end
- private :set_enum_pragma
-
- # Returns the value of the given pragma as an integer.
- def get_int_pragma( name )
- get_first_value( "PRAGMA #{name}" ).to_i
- end
- private :get_int_pragma
-
- # Set the value of the given pragma to the integer value of the +value+
- # parameter.
- def set_int_pragma( name, value )
- execute( "PRAGMA #{name}=#{value.to_i}" )
- end
- private :set_int_pragma
-
- # The enumeration of valid synchronous modes.
- SYNCHRONOUS_MODES = [ [ 'full', 2 ], [ 'normal', 1 ], [ 'off', 0 ] ]
-
- # The enumeration of valid temp store modes.
- TEMP_STORE_MODES = [ [ 'default', 0 ], [ 'file', 1 ], [ 'memory', 2 ] ]
-
- # Does an integrity check on the database. If the check fails, a
- # SQLite3::Exception will be raised. Otherwise it
- # returns silently.
- def integrity_check
- execute( "PRAGMA integrity_check" ) do |row|
- raise Exception, row[0] if row[0] != "ok"
- end
- end
-
- def auto_vacuum
- get_boolean_pragma "auto_vacuum"
- end
-
- def auto_vacuum=( mode )
- set_boolean_pragma "auto_vacuum", mode
- end
-
- def schema_cookie
- get_int_pragma "schema_cookie"
- end
-
- def schema_cookie=( cookie )
- set_int_pragma "schema_cookie", cookie
- end
-
- def user_cookie
- get_int_pragma "user_cookie"
- end
-
- def user_cookie=( cookie )
- set_int_pragma "user_cookie", cookie
- end
-
- def cache_size
- get_int_pragma "cache_size"
- end
-
- def cache_size=( size )
- set_int_pragma "cache_size", size
- end
-
- def default_cache_size
- get_int_pragma "default_cache_size"
- end
-
- def default_cache_size=( size )
- set_int_pragma "default_cache_size", size
- end
-
- def default_synchronous
- get_enum_pragma "default_synchronous"
- end
-
- def default_synchronous=( mode )
- set_enum_pragma "default_synchronous", mode, SYNCHRONOUS_MODES
- end
-
- def synchronous
- get_enum_pragma "synchronous"
- end
-
- def synchronous=( mode )
- set_enum_pragma "synchronous", mode, SYNCHRONOUS_MODES
- end
-
- def default_temp_store
- get_enum_pragma "default_temp_store"
- end
-
- def default_temp_store=( mode )
- set_enum_pragma "default_temp_store", mode, TEMP_STORE_MODES
- end
-
- def temp_store
- get_enum_pragma "temp_store"
- end
-
- def temp_store=( mode )
- set_enum_pragma "temp_store", mode, TEMP_STORE_MODES
- end
-
- def full_column_names
- get_boolean_pragma "full_column_names"
- end
-
- def full_column_names=( mode )
- set_boolean_pragma "full_column_names", mode
- end
-
- def parser_trace
- get_boolean_pragma "parser_trace"
- end
-
- def parser_trace=( mode )
- set_boolean_pragma "parser_trace", mode
- end
-
- def vdbe_trace
- get_boolean_pragma "vdbe_trace"
- end
-
- def vdbe_trace=( mode )
- set_boolean_pragma "vdbe_trace", mode
- end
-
- def database_list( &block ) # :yields: row
- get_query_pragma "database_list", &block
- end
-
- def foreign_key_list( table, &block ) # :yields: row
- get_query_pragma "foreign_key_list", table, &block
- end
-
- def index_info( index, &block ) # :yields: row
- get_query_pragma "index_info", index, &block
- end
-
- def index_list( table, &block ) # :yields: row
- get_query_pragma "index_list", table, &block
- end
-
- ###
- # Returns information about +table+. Yields each row of table information
- # if a block is provided.
- def table_info table
- stmt = prepare "PRAGMA table_info(#{table})"
- columns = stmt.columns
-
- needs_tweak_default =
- version_compare(SQLite3.libversion.to_s, "3.3.7") > 0
-
- result = [] unless block_given?
- stmt.each do |row|
- new_row = Hash[*columns.zip(row).flatten]
-
- # FIXME: This should be removed but is required for older versions
- # of rails
- if(Object.const_defined?(:ActiveRecord))
- new_row['notnull'] = new_row['notnull'].to_s
- end
-
- tweak_default(new_row) if needs_tweak_default
-
- if block_given?
- yield new_row
- else
- result << new_row
- end
- end
- stmt.close
-
- result
- end
-
- private
-
- # Compares two version strings
- def version_compare(v1, v2)
- v1 = v1.split(".").map { |i| i.to_i }
- v2 = v2.split(".").map { |i| i.to_i }
- parts = [v1.length, v2.length].max
- v1.push 0 while v1.length < parts
- v2.push 0 while v2.length < parts
- v1.zip(v2).each do |a,b|
- return -1 if a < b
- return 1 if a > b
- end
- return 0
- end
-
- # Since SQLite 3.3.8, the table_info pragma has returned the default
- # value of the row as a quoted SQL value. This method essentially
- # unquotes those values.
- def tweak_default(hash)
- case hash["dflt_value"]
- when /^null$/i
- hash["dflt_value"] = nil
- when /^'(.*)'$/
- hash["dflt_value"] = $1.gsub(/''/, "'")
- when /^"(.*)"$/
- hash["dflt_value"] = $1.gsub(/""/, '"')
- end
- end
- end
-
-end
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb
deleted file mode 100644
index bc331b08..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb
+++ /dev/null
@@ -1,126 +0,0 @@
-require 'sqlite3/constants'
-require 'sqlite3/errors'
-
-module SQLite3
-
- # The ResultSet object encapsulates the enumerability of a query's output.
- # It is a simple cursor over the data that the query returns. It will
- # very rarely (if ever) be instantiated directly. Instead, client's should
- # obtain a ResultSet instance via Statement#execute.
- class ResultSet
- include Enumerable
-
- # The class of which we return an object in case we want an Array as
- # result. (ArrayFields is installed.)
- class ArrayWithTypes < Array
- attr_accessor :types
- end
-
- # The class of which we return an object in case we want an Array as
- # result. (ArrayFields is not installed.)
- class ArrayWithTypesAndFields < Array
- attr_accessor :types
- attr_accessor :fields
- end
-
- # The class of which we return an object in case we want a Hash as
- # result.
- class HashWithTypes < Hash
- attr_accessor :types
- end
-
- # Create a new ResultSet attached to the given database, using the
- # given sql text.
- def initialize db, stmt
- @db = db
- @stmt = stmt
- end
-
- # Reset the cursor, so that a result set which has reached end-of-file
- # can be rewound and reiterated.
- def reset( *bind_params )
- @stmt.reset!
- @stmt.bind_params( *bind_params )
- @eof = false
- end
-
- # Query whether the cursor has reached the end of the result set or not.
- def eof?
- @stmt.done?
- end
-
- # Obtain the next row from the cursor. If there are no more rows to be
- # had, this will return +nil+. If type translation is active on the
- # corresponding database, the values in the row will be translated
- # according to their types.
- #
- # The returned value will be an array, unless Database#results_as_hash has
- # been set to +true+, in which case the returned value will be a hash.
- #
- # For arrays, the column names are accessible via the +fields+ property,
- # and the column types are accessible via the +types+ property.
- #
- # For hashes, the column names are the keys of the hash, and the column
- # types are accessible via the +types+ property.
- def next
- row = @stmt.step
- return nil if @stmt.done?
-
- if @db.type_translation
- row = @stmt.types.zip(row).map do |type, value|
- @db.translator.translate( type, value )
- end
- end
-
- if @db.results_as_hash
- new_row = HashWithTypes[*@stmt.columns.zip(row).flatten]
- row.each_with_index { |value,idx|
- new_row[idx] = value
- }
- row = new_row
- else
- if row.respond_to?(:fields)
- row = ArrayWithTypes.new(row)
- else
- row = ArrayWithTypesAndFields.new(row)
- end
- row.fields = @stmt.columns
- end
-
- row.types = @stmt.types
- row
- end
-
- # Required by the Enumerable mixin. Provides an internal iterator over the
- # rows of the result set.
- def each( &block )
- while node = self.next
- yield node
- end
- end
-
- # Closes the statement that spawned this result set.
- # Use with caution! Closing a result set will automatically
- # close any other result sets that were spawned from the same statement.
- def close
- @stmt.close
- end
-
- # Queries whether the underlying statement has been closed or not.
- def closed?
- @stmt.closed?
- end
-
- # Returns the types of the columns returned by this result set.
- def types
- @stmt.types
- end
-
- # Returns the names of the columns returned by this result set.
- def columns
- @stmt.columns
- end
-
- end
-
-end
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb
deleted file mode 100644
index 633244d4..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb
+++ /dev/null
@@ -1,148 +0,0 @@
-require 'sqlite3/errors'
-require 'sqlite3/resultset'
-
-class String
- def to_blob
- SQLite3::Blob.new( self )
- end
-end
-
-module SQLite3
- # A statement represents a prepared-but-unexecuted SQL query. It will rarely
- # (if ever) be instantiated directly by a client, and is most often obtained
- # via the Database#prepare method.
- class Statement
- include Enumerable
-
- # This is any text that followed the first valid SQL statement in the text
- # with which the statement was initialized. If there was no trailing text,
- # this will be the empty string.
- attr_reader :remainder
-
- # Binds the given variables to the corresponding placeholders in the SQL
- # text.
- #
- # See Database#execute for a description of the valid placeholder
- # syntaxes.
- #
- # Example:
- #
- # stmt = db.prepare( "select * from table where a=? and b=?" )
- # stmt.bind_params( 15, "hello" )
- #
- # See also #execute, #bind_param, Statement#bind_param, and
- # Statement#bind_params.
- def bind_params( *bind_vars )
- index = 1
- bind_vars.flatten.each do |var|
- if Hash === var
- var.each { |key, val| bind_param key, val }
- else
- bind_param index, var
- index += 1
- end
- end
- end
-
- # Execute the statement. This creates a new ResultSet object for the
- # statement's virtual machine. If a block was given, the new ResultSet will
- # be yielded to it; otherwise, the ResultSet will be returned.
- #
- # Any parameters will be bound to the statement using #bind_params.
- #
- # Example:
- #
- # stmt = db.prepare( "select * from table" )
- # stmt.execute do |result|
- # ...
- # end
- #
- # See also #bind_params, #execute!.
- def execute( *bind_vars )
- reset! if active? || done?
-
- bind_params(*bind_vars) unless bind_vars.empty?
- @results = ResultSet.new(@connection, self)
-
- step if 0 == column_count
-
- yield @results if block_given?
- @results
- end
-
- # Execute the statement. If no block was given, this returns an array of
- # rows returned by executing the statement. Otherwise, each row will be
- # yielded to the block.
- #
- # Any parameters will be bound to the statement using #bind_params.
- #
- # Example:
- #
- # stmt = db.prepare( "select * from table" )
- # stmt.execute! do |row|
- # ...
- # end
- #
- # See also #bind_params, #execute.
- def execute!( *bind_vars, &block )
- execute(*bind_vars)
- block_given? ? each(&block) : to_a
- end
-
- # Returns true if the statement is currently active, meaning it has an
- # open result set.
- def active?
- !done?
- end
-
- # Return an array of the column names for this statement. Note that this
- # may execute the statement in order to obtain the metadata; this makes it
- # a (potentially) expensive operation.
- def columns
- get_metadata unless @columns
- return @columns
- end
-
- def each
- loop do
- val = step
- break self if done?
- yield val
- end
- end
-
- # Return an array of the data types for each column in this statement. Note
- # that this may execute the statement in order to obtain the metadata; this
- # makes it a (potentially) expensive operation.
- def types
- must_be_open!
- get_metadata unless @types
- @types
- end
-
- # A convenience method for obtaining the metadata about the query. Note
- # that this will actually execute the SQL, which means it can be a
- # (potentially) expensive operation.
- def get_metadata
- @columns = []
- @types = []
-
- column_count.times do |column|
- @columns << column_name(column)
- @types << column_decltype(column)
- end
-
- @columns.freeze
- @types.freeze
- end
- private :get_metadata
-
- # Performs a sanity check to ensure that the statement is not
- # closed. If it is, an exception is raised.
- def must_be_open! # :nodoc:
- if closed?
- raise SQLite3::Exception, "cannot use a closed statement"
- end
- end
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/translator.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/translator.rb
deleted file mode 100644
index cae36941..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/translator.rb
+++ /dev/null
@@ -1,114 +0,0 @@
-require 'time'
-require 'date'
-
-module SQLite3
-
- # The Translator class encapsulates the logic and callbacks necessary for
- # converting string data to a value of some specified type. Every Database
- # instance may have a Translator instance, in order to assist in type
- # translation (Database#type_translation).
- #
- # Further, applications may define their own custom type translation logic
- # by registering translator blocks with the corresponding database's
- # translator instance (Database#translator).
- class Translator
-
- # Create a new Translator instance. It will be preinitialized with default
- # translators for most SQL data types.
- def initialize
- @translators = Hash.new( proc { |type,value| value } )
- @type_name_cache = {}
- register_default_translators
- end
-
- # Add a new translator block, which will be invoked to process type
- # translations to the given type. The type should be an SQL datatype, and
- # may include parentheses (i.e., "VARCHAR(30)"). However, any parenthetical
- # information is stripped off and discarded, so type translation decisions
- # are made solely on the "base" type name.
- #
- # The translator block itself should accept two parameters, "type" and
- # "value". In this case, the "type" is the full type name (including
- # parentheses), so the block itself may include logic for changing how a
- # type is translated based on the additional data. The "value" parameter
- # is the (string) data to convert.
- #
- # The block should return the translated value.
- def add_translator( type, &block ) # :yields: type, value
- @translators[ type_name( type ) ] = block
- end
-
- # Translate the given string value to a value of the given type. In the
- # absense of an installed translator block for the given type, the value
- # itself is always returned. Further, +nil+ values are never translated,
- # and are always passed straight through regardless of the type parameter.
- def translate( type, value )
- unless value.nil?
- # FIXME: this is a hack to support Sequel
- if type && %w{ datetime timestamp }.include?(type.downcase)
- @translators[ type_name( type ) ].call( type, value.to_s )
- else
- @translators[ type_name( type ) ].call( type, value )
- end
- end
- end
-
- # A convenience method for working with type names. This returns the "base"
- # type name, without any parenthetical data.
- def type_name( type )
- @type_name_cache[type] ||= begin
- type = "" if type.nil?
- type = $1 if type =~ /^(.*?)\(/
- type.upcase
- end
- end
- private :type_name
-
- # Register the default translators for the current Translator instance.
- # This includes translators for most major SQL data types.
- def register_default_translators
- [ "time",
- "timestamp" ].each { |type| add_translator( type ) { |t, v| Time.parse( v ) } }
-
- add_translator( "date" ) { |t,v| Date.parse(v) }
- add_translator( "datetime" ) { |t,v| DateTime.parse(v) }
-
- [ "decimal",
- "float",
- "numeric",
- "double",
- "real",
- "dec",
- "fixed" ].each { |type| add_translator( type ) { |t,v| v.to_f } }
-
- [ "integer",
- "smallint",
- "mediumint",
- "int",
- "bigint" ].each { |type| add_translator( type ) { |t,v| v.to_i } }
-
- [ "bit",
- "bool",
- "boolean" ].each do |type|
- add_translator( type ) do |t,v|
- !( v.strip.gsub(/00+/,"0") == "0" ||
- v.downcase == "false" ||
- v.downcase == "f" ||
- v.downcase == "no" ||
- v.downcase == "n" )
- end
- end
-
- add_translator( "tinyint" ) do |type, value|
- if type =~ /\(\s*1\s*\)/
- value.to_i == 1
- else
- value.to_i
- end
- end
- end
- private :register_default_translators
-
- end
-
-end
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/value.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/value.rb
deleted file mode 100644
index e5e5bf2c..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/value.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-require 'sqlite3/constants'
-
-module SQLite3
-
- class Value
- attr_reader :handle
-
- def initialize( db, handle )
- @driver = db.driver
- @handle = handle
- end
-
- def null?
- type == :null
- end
-
- def to_blob
- @driver.value_blob( @handle )
- end
-
- def length( utf16=false )
- if utf16
- @driver.value_bytes16( @handle )
- else
- @driver.value_bytes( @handle )
- end
- end
-
- def to_f
- @driver.value_double( @handle )
- end
-
- def to_i
- @driver.value_int( @handle )
- end
-
- def to_int64
- @driver.value_int64( @handle )
- end
-
- def to_s( utf16=false )
- @driver.value_text( @handle, utf16 )
- end
-
- def type
- case @driver.value_type( @handle )
- when Constants::ColumnType::INTEGER then :int
- when Constants::ColumnType::FLOAT then :float
- when Constants::ColumnType::TEXT then :text
- when Constants::ColumnType::BLOB then :blob
- when Constants::ColumnType::NULL then :null
- end
- end
-
- end
-
-end
diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb
deleted file mode 100644
index 22ce3cfd..00000000
--- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-module SQLite3
-
- module Version
-
- MAJOR = 1
- MINOR = 3
- TINY = 1
- BUILD = nil
-
- STRING = [ MAJOR, MINOR, TINY, BUILD ].compact.join( "." )
- #:beta-tag:
-
- VERSION = '1.3.1'
- end
-
-end
diff --git a/vendor/plugins/sqlite3-ruby/setup.rb b/vendor/plugins/sqlite3-ruby/setup.rb
deleted file mode 100644
index 82b45091..00000000
--- a/vendor/plugins/sqlite3-ruby/setup.rb
+++ /dev/null
@@ -1,1333 +0,0 @@
-#
-# setup.rb
-#
-# Copyright (c) 2000-2004 Minero Aoki
-#
-# This program is free software.
-# You can distribute/modify this program under the terms of
-# the GNU LGPL, Lesser General Public License version 2.1.
-#
-
-#
-# For backward compatibility
-#
-
-unless Enumerable.method_defined?(:map)
- module Enumerable
- alias map collect
- end
-end
-
-unless Enumerable.method_defined?(:detect)
- module Enumerable
- alias detect find
- end
-end
-
-unless Enumerable.method_defined?(:select)
- module Enumerable
- alias select find_all
- end
-end
-
-unless Enumerable.method_defined?(:reject)
- module Enumerable
- def reject
- select {|i| not yield(i) }
- end
- end
-end
-
-unless Enumerable.method_defined?(:inject)
- module Enumerable
- def inject(result)
- each do |i|
- result = yield(result, i)
- end
- result
- end
- end
-end
-
-unless Enumerable.method_defined?(:any?)
- module Enumerable
- def any?
- each do |i|
- return true if yield(i)
- end
- false
- end
- end
-end
-
-unless File.respond_to?(:read)
- def File.read(fname)
- open(fname) {|f|
- return f.read
- }
- end
-end
-
-#
-# Application independent utilities
-#
-
-def File.binread(fname)
- open(fname, 'rb') {|f|
- return f.read
- }
-end
-
-# for corrupted windows stat(2)
-def File.dir?(path)
- File.directory?((path[-1,1] == '/') ? path : path + '/')
-end
-
-#
-# Config
-#
-
-if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg }
- ARGV.delete(arg)
- require arg.split(/=/, 2)[1]
- $".push 'rbconfig.rb'
-else
- require 'rbconfig'
-end
-
-def multipackage_install?
- FileTest.directory?(File.dirname($0) + '/packages')
-end
-
-
-class ConfigTable
-
- c = ::Config::CONFIG
-
- rubypath = c['bindir'] + '/' + c['ruby_install_name']
-
- major = c['MAJOR'].to_i
- minor = c['MINOR'].to_i
- teeny = c['TEENY'].to_i
- version = "#{major}.#{minor}"
-
- # ruby ver. >= 1.4.4?
- newpath_p = ((major >= 2) or
- ((major == 1) and
- ((minor >= 5) or
- ((minor == 4) and (teeny >= 4)))))
-
- subprefix = lambda {|path|
- path.sub(/\A#{Regexp.quote(c['prefix'])}/o, '$prefix')
- }
-
- if c['rubylibdir']
- # V < 1.6.3
- stdruby = subprefix.call(c['rubylibdir'])
- siteruby = subprefix.call(c['sitedir'])
- versite = subprefix.call(c['sitelibdir'])
- sodir = subprefix.call(c['sitearchdir'])
- elsif newpath_p
- # 1.4.4 <= V <= 1.6.3
- stdruby = "$prefix/lib/ruby/#{version}"
- siteruby = subprefix.call(c['sitedir'])
- versite = siteruby + '/' + version
- sodir = "$site-ruby/#{c['arch']}"
- else
- # V < 1.4.4
- stdruby = "$prefix/lib/ruby/#{version}"
- siteruby = "$prefix/lib/ruby/#{version}/site_ruby"
- versite = siteruby
- sodir = "$site-ruby/#{c['arch']}"
- end
-
- if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg }
- makeprog = arg.sub(/'/, '').split(/=/, 2)[1]
- else
- makeprog = 'make'
- end
-
- common_descripters = [
- [ 'prefix', [ c['prefix'],
- 'path',
- 'path prefix of target environment' ] ],
- [ 'std-ruby', [ stdruby,
- 'path',
- 'the directory for standard ruby libraries' ] ],
- [ 'site-ruby-common', [ siteruby,
- 'path',
- 'the directory for version-independent non-standard ruby libraries' ] ],
- [ 'site-ruby', [ versite,
- 'path',
- 'the directory for non-standard ruby libraries' ] ],
- [ 'bin-dir', [ '$prefix/bin',
- 'path',
- 'the directory for commands' ] ],
- [ 'rb-dir', [ '$site-ruby',
- 'path',
- 'the directory for ruby scripts' ] ],
- [ 'so-dir', [ sodir,
- 'path',
- 'the directory for ruby extentions' ] ],
- [ 'data-dir', [ '$prefix/share',
- 'path',
- 'the directory for shared data' ] ],
- [ 'ruby-path', [ rubypath,
- 'path',
- 'path to set to #! line' ] ],
- [ 'ruby-prog', [ rubypath,
- 'name',
- 'the ruby program using for installation' ] ],
- [ 'make-prog', [ makeprog,
- 'name',
- 'the make program to compile ruby extentions' ] ],
- [ 'without-ext', [ 'no',
- 'yes/no',
- 'does not compile/install ruby extentions' ] ]
- ]
- multipackage_descripters = [
- [ 'with', [ '',
- 'name,name...',
- 'package names that you want to install',
- 'ALL' ] ],
- [ 'without', [ '',
- 'name,name...',
- 'package names that you do not want to install',
- 'NONE' ] ]
- ]
- if multipackage_install?
- DESCRIPTER = common_descripters + multipackage_descripters
- else
- DESCRIPTER = common_descripters
- end
-
- SAVE_FILE = '.config'
-
- def ConfigTable.each_name(&block)
- keys().each(&block)
- end
-
- def ConfigTable.keys
- DESCRIPTER.map {|name, *dummy| name }
- end
-
- def ConfigTable.each_definition(&block)
- DESCRIPTER.each(&block)
- end
-
- def ConfigTable.get_entry(name)
- name, ent = DESCRIPTER.assoc(name)
- ent
- end
-
- def ConfigTable.get_entry!(name)
- get_entry(name) or raise ArgumentError, "no such config: #{name}"
- end
-
- def ConfigTable.add_entry(name, vals)
- ConfigTable::DESCRIPTER.push [name,vals]
- end
-
- def ConfigTable.remove_entry(name)
- get_entry(name) or raise ArgumentError, "no such config: #{name}"
- DESCRIPTER.delete_if {|n, arr| n == name }
- end
-
- def ConfigTable.config_key?(name)
- get_entry(name) ? true : false
- end
-
- def ConfigTable.bool_config?(name)
- ent = get_entry(name) or return false
- ent[1] == 'yes/no'
- end
-
- def ConfigTable.value_config?(name)
- ent = get_entry(name) or return false
- ent[1] != 'yes/no'
- end
-
- def ConfigTable.path_config?(name)
- ent = get_entry(name) or return false
- ent[1] == 'path'
- end
-
-
- class << self
- alias newobj new
- end
-
- def ConfigTable.new
- c = newobj()
- c.initialize_from_table
- c
- end
-
- def ConfigTable.load
- c = newobj()
- c.initialize_from_file
- c
- end
-
- def initialize_from_table
- @table = {}
- DESCRIPTER.each do |k, (default, vname, desc, default2)|
- @table[k] = default
- end
- end
-
- def initialize_from_file
- raise InstallError, "#{File.basename $0} config first"\
- unless File.file?(SAVE_FILE)
- @table = {}
- File.foreach(SAVE_FILE) do |line|
- k, v = line.split(/=/, 2)
- @table[k] = v.strip
- end
- end
-
- def save
- File.open(SAVE_FILE, 'w') {|f|
- @table.each do |k, v|
- f.printf "%s=%s\n", k, v if v
- end
- }
- end
-
- def []=(k, v)
- raise InstallError, "unknown config option #{k}"\
- unless ConfigTable.config_key?(k)
- @table[k] = v
- end
-
- def [](key)
- return nil unless @table[key]
- @table[key].gsub(%r<\$([^/]+)>) { self[$1] }
- end
-
- def set_raw(key, val)
- @table[key] = val
- end
-
- def get_raw(key)
- @table[key]
- end
-
-end
-
-
-module MetaConfigAPI
-
- def eval_file_ifexist(fname)
- instance_eval File.read(fname), fname, 1 if File.file?(fname)
- end
-
- def config_names
- ConfigTable.keys
- end
-
- def config?(name)
- ConfigTable.config_key?(name)
- end
-
- def bool_config?(name)
- ConfigTable.bool_config?(name)
- end
-
- def value_config?(name)
- ConfigTable.value_config?(name)
- end
-
- def path_config?(name)
- ConfigTable.path_config?(name)
- end
-
- def add_config(name, argname, default, desc)
- ConfigTable.add_entry name,[default,argname,desc]
- end
-
- def add_path_config(name, default, desc)
- add_config name, 'path', default, desc
- end
-
- def add_bool_config(name, default, desc)
- add_config name, 'yes/no', default ? 'yes' : 'no', desc
- end
-
- def set_config_default(name, default)
- if bool_config?(name)
- ConfigTable.get_entry!(name)[0] = (default ? 'yes' : 'no')
- else
- ConfigTable.get_entry!(name)[0] = default
- end
- end
-
- def remove_config(name)
- ent = ConfigTable.get_entry(name)
- ConfigTable.remove_entry name
- ent
- end
-
-end
-
-#
-# File Operations
-#
-
-module FileOperations
-
- def mkdir_p(dirname, prefix = nil)
- dirname = prefix + dirname if prefix
- $stderr.puts "mkdir -p #{dirname}" if verbose?
- return if no_harm?
-
- # does not check '/'... it's too abnormal case
- dirs = dirname.split(%r<(?=/)>)
- if /\A[a-z]:\z/i =~ dirs[0]
- disk = dirs.shift
- dirs[0] = disk + dirs[0]
- end
- dirs.each_index do |idx|
- path = dirs[0..idx].join('')
- Dir.mkdir path unless File.dir?(path)
- end
- end
-
- def rm_f(fname)
- $stderr.puts "rm -f #{fname}" if verbose?
- return if no_harm?
-
- if File.exist?(fname) or File.symlink?(fname)
- File.chmod 0777, fname
- File.unlink fname
- end
- end
-
- def rm_rf(dn)
- $stderr.puts "rm -rf #{dn}" if verbose?
- return if no_harm?
-
- Dir.chdir dn
- Dir.foreach('.') do |fn|
- next if fn == '.'
- next if fn == '..'
- if File.dir?(fn)
- verbose_off {
- rm_rf fn
- }
- else
- verbose_off {
- rm_f fn
- }
- end
- end
- Dir.chdir '..'
- Dir.rmdir dn
- end
-
- def move_file(src, dest)
- File.unlink dest if File.exist?(dest)
- begin
- File.rename src, dest
- rescue
- File.open(dest, 'wb') {|f| f.write File.binread(src) }
- File.chmod File.stat(src).mode, dest
- File.unlink src
- end
- end
-
- def install(from, dest, mode, prefix = nil)
- $stderr.puts "install #{from} #{dest}" if verbose?
- return if no_harm?
-
- realdest = prefix ? prefix + dest : dest
- realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest)
- str = File.binread(from)
- if diff?(str, realdest)
- verbose_off {
- rm_f realdest if File.exist?(realdest)
- }
- File.open(realdest, 'wb') {|f|
- f.write str
- }
- File.chmod mode, realdest
-
- File.open("#{objdir_root()}/InstalledFiles", 'a') {|f|
- if prefix
- f.puts realdest.sub(prefix, '')
- else
- f.puts realdest
- end
- }
- end
- end
-
- def diff?(new_content, path)
- return true unless File.exist?(path)
- new_content != File.binread(path)
- end
-
- def command(str)
- $stderr.puts str if verbose?
- system str or raise RuntimeError, "'system #{str}' failed"
- end
-
- def ruby(str)
- command config('ruby-prog') + ' ' + str
- end
-
- def make(task = '')
- command config('make-prog') + ' ' + task
- end
-
- def extdir?(dir)
- File.exist?(dir + '/MANIFEST') or File.exist?("#{dir}/extconf.rb")
- end
-
- def all_files_in(dirname)
- Dir.open(dirname) {|d|
- return d.select {|ent| File.file?("#{dirname}/#{ent}") }
- }
- end
-
- REJECT_DIRS = %w(
- CVS SCCS RCS CVS.adm .svn
- )
-
- def all_dirs_in(dirname)
- Dir.open(dirname) {|d|
- return d.select {|n| File.dir?("#{dirname}/#{n}") } - %w(. ..) - REJECT_DIRS
- }
- end
-
-end
-
-#
-# Main Installer
-#
-
-class InstallError < StandardError; end
-
-
-module HookUtils
-
- def run_hook(name)
- try_run_hook "#{curr_srcdir()}/#{name}" or
- try_run_hook "#{curr_srcdir()}/#{name}.rb"
- end
-
- def try_run_hook(fname)
- return false unless File.file?(fname)
- begin
- instance_eval File.read(fname), fname, 1
- rescue
- raise InstallError, "hook #{fname} failed:\n" + $!.message
- end
- true
- end
-
-end
-
-
-module HookScriptAPI
-
- def get_config(key)
- @config[key]
- end
-
- alias config get_config
-
- def set_config(key, val)
- @config[key] = val
- end
-
- #
- # srcdir/objdir (works only in the package directory)
- #
-
- #abstract srcdir_root
- #abstract objdir_root
- #abstract relpath
-
- def curr_srcdir
- "#{srcdir_root()}/#{relpath()}"
- end
-
- def curr_objdir
- "#{objdir_root()}/#{relpath()}"
- end
-
- def srcfile(path)
- "#{curr_srcdir()}/#{path}"
- end
-
- def srcexist?(path)
- File.exist?(srcfile(path))
- end
-
- def srcdirectory?(path)
- File.dir?(srcfile(path))
- end
-
- def srcfile?(path)
- File.file? srcfile(path)
- end
-
- def srcentries(path = '.')
- Dir.open("#{curr_srcdir()}/#{path}") {|d|
- return d.to_a - %w(. ..)
- }
- end
-
- def srcfiles(path = '.')
- srcentries(path).select {|fname|
- File.file?(File.join(curr_srcdir(), path, fname))
- }
- end
-
- def srcdirectories(path = '.')
- srcentries(path).select {|fname|
- File.dir?(File.join(curr_srcdir(), path, fname))
- }
- end
-
-end
-
-
-class ToplevelInstaller
-
- Version = '3.3.0'
- Copyright = 'Copyright (c) 2000-2004 Minero Aoki'
-
- TASKS = [
- [ 'all', 'do config, setup, then install' ],
- [ 'config', 'saves your configurations' ],
- [ 'show', 'shows current configuration' ],
- [ 'setup', 'compiles ruby extentions and others' ],
- [ 'install', 'installs files' ],
- [ 'clean', "does `make clean' for each extention" ],
- [ 'distclean',"does `make distclean' for each extention" ]
- ]
-
- def ToplevelInstaller.invoke
- instance().invoke
- end
-
- @singleton = nil
-
- def ToplevelInstaller.instance
- @singleton ||= new(File.dirname($0))
- @singleton
- end
-
- include MetaConfigAPI
-
- def initialize(ardir_root)
- @config = nil
- @options = { 'verbose' => true }
- @ardir = File.expand_path(ardir_root)
- end
-
- def inspect
- "#<#{self.class} #{__id__()}>"
- end
-
- def invoke
- run_metaconfigs
- case task = parsearg_global()
- when nil, 'all'
- @config = load_config('config')
- parsearg_config
- init_installers
- exec_config
- exec_setup
- exec_install
- else
- @config = load_config(task)
- __send__ "parsearg_#{task}"
- init_installers
- __send__ "exec_#{task}"
- end
- end
-
- def run_metaconfigs
- eval_file_ifexist "#{@ardir}/metaconfig"
- end
-
- def load_config(task)
- case task
- when 'config'
- ConfigTable.new
- when 'clean', 'distclean'
- if File.exist?(ConfigTable::SAVE_FILE)
- then ConfigTable.load
- else ConfigTable.new
- end
- else
- ConfigTable.load
- end
- end
-
- def init_installers
- @installer = Installer.new(@config, @options, @ardir, File.expand_path('.'))
- end
-
- #
- # Hook Script API bases
- #
-
- def srcdir_root
- @ardir
- end
-
- def objdir_root
- '.'
- end
-
- def relpath
- '.'
- end
-
- #
- # Option Parsing
- #
-
- def parsearg_global
- valid_task = /\A(?:#{TASKS.map {|task,desc| task }.join '|'})\z/
-
- while arg = ARGV.shift
- case arg
- when /\A\w+\z/
- raise InstallError, "invalid task: #{arg}" unless valid_task =~ arg
- return arg
-
- when '-q', '--quiet'
- @options['verbose'] = false
-
- when '--verbose'
- @options['verbose'] = true
-
- when '-h', '--help'
- print_usage $stdout
- exit 0
-
- when '-v', '--version'
- puts "#{File.basename($0)} version #{Version}"
- exit 0
-
- when '--copyright'
- puts Copyright
- exit 0
-
- else
- raise InstallError, "unknown global option '#{arg}'"
- end
- end
-
- nil
- end
-
-
- def parsearg_no_options
- raise InstallError, "#{task}: unknown options: #{ARGV.join ' '}"\
- unless ARGV.empty?
- end
-
- alias parsearg_show parsearg_no_options
- alias parsearg_setup parsearg_no_options
- alias parsearg_clean parsearg_no_options
- alias parsearg_distclean parsearg_no_options
-
- def parsearg_config
- re = /\A--(#{ConfigTable.keys.join '|'})(?:=(.*))?\z/
- @options['config-opt'] = []
-
- while i = ARGV.shift
- if /\A--?\z/ =~ i
- @options['config-opt'] = ARGV.dup
- break
- end
- m = re.match(i) or raise InstallError, "config: unknown option #{i}"
- name, value = m.to_a[1,2]
- if value
- if ConfigTable.bool_config?(name)
- raise InstallError, "config: --#{name} allows only yes/no for argument"\
- unless /\A(y(es)?|n(o)?|t(rue)?|f(alse))\z/i =~ value
- value = (/\Ay(es)?|\At(rue)/i =~ value) ? 'yes' : 'no'
- end
- else
- raise InstallError, "config: --#{name} requires argument"\
- unless ConfigTable.bool_config?(name)
- value = 'yes'
- end
- @config[name] = value
- end
- end
-
- def parsearg_install
- @options['no-harm'] = false
- @options['install-prefix'] = ''
- while a = ARGV.shift
- case a
- when /\A--no-harm\z/
- @options['no-harm'] = true
- when /\A--prefix=(.*)\z/
- path = $1
- path = File.expand_path(path) unless path[0,1] == '/'
- @options['install-prefix'] = path
- else
- raise InstallError, "install: unknown option #{a}"
- end
- end
- end
-
- def print_usage(out)
- out.puts 'Typical Installation Procedure:'
- out.puts " $ ruby #{File.basename $0} config"
- out.puts " $ ruby #{File.basename $0} setup"
- out.puts " # ruby #{File.basename $0} install (may require root privilege)"
- out.puts
- out.puts 'Detailed Usage:'
- out.puts " ruby #{File.basename $0} "
- out.puts " ruby #{File.basename $0} [] []"
-
- fmt = " %-20s %s\n"
- out.puts
- out.puts 'Global options:'
- out.printf fmt, '-q,--quiet', 'suppress message outputs'
- out.printf fmt, ' --verbose', 'output messages verbosely'
- out.printf fmt, '-h,--help', 'print this message'
- out.printf fmt, '-v,--version', 'print version and quit'
- out.printf fmt, ' --copyright', 'print copyright and quit'
-
- out.puts
- out.puts 'Tasks:'
- TASKS.each do |name, desc|
- out.printf " %-10s %s\n", name, desc
- end
-
- out.puts
- out.puts 'Options for CONFIG or ALL:'
- ConfigTable.each_definition do |name, (default, arg, desc, default2)|
- out.printf " %-20s %s [%s]\n",
- '--'+ name + (ConfigTable.bool_config?(name) ? '' : '='+arg),
- desc,
- default2 || default
- end
- out.printf " %-20s %s [%s]\n",
- '--rbconfig=path', 'your rbconfig.rb to load', "running ruby's"
-
- out.puts
- out.puts 'Options for INSTALL:'
- out.printf " %-20s %s [%s]\n",
- '--no-harm', 'only display what to do if given', 'off'
- out.printf " %-20s %s [%s]\n",
- '--prefix', 'install path prefix', '$prefix'
-
- out.puts
- end
-
- #
- # Task Handlers
- #
-
- def exec_config
- @installer.exec_config
- @config.save # must be final
- end
-
- def exec_setup
- @installer.exec_setup
- end
-
- def exec_install
- @installer.exec_install
- end
-
- def exec_show
- ConfigTable.each_name do |k|
- v = @config.get_raw(k)
- if not v or v.empty?
- v = '(not specified)'
- end
- printf "%-10s %s\n", k, v
- end
- end
-
- def exec_clean
- @installer.exec_clean
- end
-
- def exec_distclean
- @installer.exec_distclean
- end
-
-end
-
-
-class ToplevelInstallerMulti < ToplevelInstaller
-
- include HookUtils
- include HookScriptAPI
- include FileOperations
-
- def initialize(ardir)
- super
- @packages = all_dirs_in("#{@ardir}/packages")
- raise 'no package exists' if @packages.empty?
- end
-
- def run_metaconfigs
- eval_file_ifexist "#{@ardir}/metaconfig"
- @packages.each do |name|
- eval_file_ifexist "#{@ardir}/packages/#{name}/metaconfig"
- end
- end
-
- def init_installers
- @installers = {}
- @packages.each do |pack|
- @installers[pack] = Installer.new(@config, @options,
- "#{@ardir}/packages/#{pack}",
- "packages/#{pack}")
- end
-
- with = extract_selection(config('with'))
- without = extract_selection(config('without'))
- @selected = @installers.keys.select {|name|
- (with.empty? or with.include?(name)) \
- and not without.include?(name)
- }
- end
-
- def extract_selection(list)
- a = list.split(/,/)
- a.each do |name|
- raise InstallError, "no such package: #{name}" \
- unless @installers.key?(name)
- end
- a
- end
-
- def print_usage(f)
- super
- f.puts 'Inluded packages:'
- f.puts ' ' + @packages.sort.join(' ')
- f.puts
- end
-
- #
- # multi-package metaconfig API
- #
-
- attr_reader :packages
-
- def declare_packages(list)
- raise 'package list is empty' if list.empty?
- list.each do |name|
- raise "directory packages/#{name} does not exist"\
- unless File.dir?("#{@ardir}/packages/#{name}")
- end
- @packages = list
- end
-
- #
- # Task Handlers
- #
-
- def exec_config
- run_hook 'pre-config'
- each_selected_installers {|inst| inst.exec_config }
- run_hook 'post-config'
- @config.save # must be final
- end
-
- def exec_setup
- run_hook 'pre-setup'
- each_selected_installers {|inst| inst.exec_setup }
- run_hook 'post-setup'
- end
-
- def exec_install
- run_hook 'pre-install'
- each_selected_installers {|inst| inst.exec_install }
- run_hook 'post-install'
- end
-
- def exec_clean
- rm_f ConfigTable::SAVE_FILE
- run_hook 'pre-clean'
- each_selected_installers {|inst| inst.exec_clean }
- run_hook 'post-clean'
- end
-
- def exec_distclean
- rm_f ConfigTable::SAVE_FILE
- run_hook 'pre-distclean'
- each_selected_installers {|inst| inst.exec_distclean }
- run_hook 'post-distclean'
- end
-
- #
- # lib
- #
-
- def each_selected_installers
- Dir.mkdir 'packages' unless File.dir?('packages')
- @selected.each do |pack|
- $stderr.puts "Processing the package `#{pack}' ..." if @options['verbose']
- Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}")
- Dir.chdir "packages/#{pack}"
- yield @installers[pack]
- Dir.chdir '../..'
- end
- end
-
- def verbose?
- @options['verbose']
- end
-
- def no_harm?
- @options['no-harm']
- end
-
-end
-
-
-class Installer
-
- FILETYPES = %w( bin lib ext data )
-
- include HookScriptAPI
- include HookUtils
- include FileOperations
-
- def initialize(config, opt, srcroot, objroot)
- @config = config
- @options = opt
- @srcdir = File.expand_path(srcroot)
- @objdir = File.expand_path(objroot)
- @currdir = '.'
- end
-
- def inspect
- "#<#{self.class} #{File.basename(@srcdir)}>"
- end
-
- #
- # Hook Script API bases
- #
-
- def srcdir_root
- @srcdir
- end
-
- def objdir_root
- @objdir
- end
-
- def relpath
- @currdir
- end
-
- #
- # configs/options
- #
-
- def no_harm?
- @options['no-harm']
- end
-
- def verbose?
- @options['verbose']
- end
-
- def verbose_off
- begin
- save, @options['verbose'] = @options['verbose'], false
- yield
- ensure
- @options['verbose'] = save
- end
- end
-
- #
- # TASK config
- #
-
- def exec_config
- exec_task_traverse 'config'
- end
-
- def config_dir_bin(rel)
- end
-
- def config_dir_lib(rel)
- end
-
- def config_dir_ext(rel)
- extconf if extdir?(curr_srcdir())
- end
-
- def extconf
- opt = @options['config-opt'].join(' ')
- command "#{config('ruby-prog')} #{curr_srcdir()}/extconf.rb #{opt}"
- end
-
- def config_dir_data(rel)
- end
-
- #
- # TASK setup
- #
-
- def exec_setup
- exec_task_traverse 'setup'
- end
-
- def setup_dir_bin(rel)
- all_files_in(curr_srcdir()).each do |fname|
- adjust_shebang "#{curr_srcdir()}/#{fname}"
- end
- end
-
- def adjust_shebang(path)
- return if no_harm?
- tmpfile = File.basename(path) + '.tmp'
- begin
- File.open(path, 'rb') {|r|
- File.open(tmpfile, 'wb') {|w|
- first = r.gets
- return unless should_modify_shebang?(first)
- $stderr.puts "adjusting shebang: #{File.basename(path)}" if verbose?
- w.print first.sub(SHEBANG_RE, '#!' + config('ruby-path'))
- w.write r.read
- }
- }
- move_file tmpfile, File.basename(path)
- ensure
- File.unlink tmpfile if File.exist?(tmpfile)
- end
- end
-
- def should_modify_shebang?(line)
- File.basename(config('ruby-path')) == 'ruby' or
- shebang_command(line) == 'ruby'
- end
-
- def shebang_command(line)
- cmd, arg = *line.sub(/\A\#!/, '').strip.split(/\s+/, 2)
- cmd
- end
-
- def setup_dir_lib(rel)
- end
-
- def setup_dir_ext(rel)
- make if extdir?(curr_srcdir())
- end
-
- def setup_dir_data(rel)
- end
-
- #
- # TASK install
- #
-
- def exec_install
- exec_task_traverse 'install'
- end
-
- def install_dir_bin(rel)
- install_files collect_filenames_auto(), "#{config('bin-dir')}/#{rel}", 0755
- end
-
- def install_dir_lib(rel)
- install_files ruby_scripts(), "#{config('rb-dir')}/#{rel}", 0644
- end
-
- def install_dir_ext(rel)
- return unless extdir?(curr_srcdir())
- install_files ruby_extentions('.'),
- "#{config('so-dir')}/#{rel}",
- 0555
- end
-
- def install_dir_data(rel)
- install_files collect_filenames_auto(), "#{config('data-dir')}/#{rel}", 0644
- end
-
- def install_files(list, dest, mode)
- mkdir_p dest, @options['install-prefix']
- list.each do |fname|
- install fname, dest, mode, @options['install-prefix']
- end
- end
-
- def ruby_scripts
- collect_filenames_auto().select {|n| /\.rb\z/ =~ n }
- end
-
- # picked up many entries from cvs-1.11.1/src/ignore.c
- reject_patterns = %w(
- core RCSLOG tags TAGS .make.state
- .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb
- *~ *.old *.bak *.BAK *.orig *.rej _$* *$
-
- *.org *.in .*
- )
- mapping = {
- '.' => '\.',
- '$' => '\$',
- '#' => '\#',
- '*' => '.*'
- }
- REJECT_PATTERNS = Regexp.new('\A(?:' +
- reject_patterns.map {|pat|
- pat.gsub(/[\.\$\#\*]/) {|ch| mapping[ch] }
- }.join('|') +
- ')\z')
-
- def collect_filenames_auto
- mapdir((existfiles() - hookfiles()).reject {|fname|
- REJECT_PATTERNS =~ fname
- })
- end
-
- def existfiles
- all_files_in(curr_srcdir()) | all_files_in('.')
- end
-
- def hookfiles
- %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt|
- %w( config setup install clean ).map {|t| sprintf(fmt, t) }
- }.flatten
- end
-
- def mapdir(filelist)
- filelist.map {|fname|
- if File.exist?(fname) # objdir
- fname
- else # srcdir
- File.join(curr_srcdir(), fname)
- end
- }
- end
-
- def ruby_extentions(dir)
- _ruby_extentions(dir) or
- raise InstallError, "no ruby extention exists: 'ruby #{$0} setup' first"
- end
-
- DLEXT = /\.#{ ::Config::CONFIG['DLEXT'] }\z/
-
- def _ruby_extentions(dir)
- Dir.open(dir) {|d|
- return d.select {|fname| DLEXT =~ fname }
- }
- end
-
- #
- # TASK clean
- #
-
- def exec_clean
- exec_task_traverse 'clean'
- rm_f ConfigTable::SAVE_FILE
- rm_f 'InstalledFiles'
- end
-
- def clean_dir_bin(rel)
- end
-
- def clean_dir_lib(rel)
- end
-
- def clean_dir_ext(rel)
- return unless extdir?(curr_srcdir())
- make 'clean' if File.file?('Makefile')
- end
-
- def clean_dir_data(rel)
- end
-
- #
- # TASK distclean
- #
-
- def exec_distclean
- exec_task_traverse 'distclean'
- rm_f ConfigTable::SAVE_FILE
- rm_f 'InstalledFiles'
- end
-
- def distclean_dir_bin(rel)
- end
-
- def distclean_dir_lib(rel)
- end
-
- def distclean_dir_ext(rel)
- return unless extdir?(curr_srcdir())
- make 'distclean' if File.file?('Makefile')
- end
-
- #
- # lib
- #
-
- def exec_task_traverse(task)
- run_hook "pre-#{task}"
- FILETYPES.each do |type|
- if config('without-ext') == 'yes' and type == 'ext'
- $stderr.puts 'skipping ext/* by user option' if verbose?
- next
- end
- traverse task, type, "#{task}_dir_#{type}"
- end
- run_hook "post-#{task}"
- end
-
- def traverse(task, rel, mid)
- dive_into(rel) {
- run_hook "pre-#{task}"
- __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '')
- all_dirs_in(curr_srcdir()).each do |d|
- traverse task, "#{rel}/#{d}", mid
- end
- run_hook "post-#{task}"
- }
- end
-
- def dive_into(rel)
- return unless File.dir?("#{@srcdir}/#{rel}")
-
- dir = File.basename(rel)
- Dir.mkdir dir unless File.dir?(dir)
- prevdir = Dir.pwd
- Dir.chdir dir
- $stderr.puts '---> ' + rel if verbose?
- @currdir = rel
- yield
- Dir.chdir prevdir
- $stderr.puts '<--- ' + rel if verbose?
- @currdir = File.dirname(rel)
- end
-
-end
-
-
-if $0 == __FILE__
- begin
- if multipackage_install?
- ToplevelInstallerMulti.invoke
- else
- ToplevelInstaller.invoke
- end
- rescue
- raise if $DEBUG
- $stderr.puts $!.message
- $stderr.puts "Try 'ruby #{$0} --help' for detailed usage."
- exit 1
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/test/helper.rb b/vendor/plugins/sqlite3-ruby/test/helper.rb
deleted file mode 100644
index a61859e6..00000000
--- a/vendor/plugins/sqlite3-ruby/test/helper.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-require 'sqlite3'
-require 'test/unit'
-require 'iconv'
diff --git a/vendor/plugins/sqlite3-ruby/test/test_collation.rb b/vendor/plugins/sqlite3-ruby/test/test_collation.rb
deleted file mode 100644
index 3400a461..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_collation.rb
+++ /dev/null
@@ -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
diff --git a/vendor/plugins/sqlite3-ruby/test/test_database.rb b/vendor/plugins/sqlite3-ruby/test/test_database.rb
deleted file mode 100644
index eda5147c..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_database.rb
+++ /dev/null
@@ -1,295 +0,0 @@
-require 'helper'
-require 'iconv'
-
-module SQLite3
- class TestDatabase < Test::Unit::TestCase
- def setup
- @db = SQLite3::Database.new(':memory:')
- 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
diff --git a/vendor/plugins/sqlite3-ruby/test/test_deprecated.rb b/vendor/plugins/sqlite3-ruby/test/test_deprecated.rb
deleted file mode 100644
index e1396cad..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_deprecated.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-require 'helper'
-
-module SQLite3
- class TestDeprecated < Test::Unit::TestCase
- def setup
- super
- @warn_before = $-w
- $-w = false
- @db = SQLite3::Database.new(':memory:')
- end
-
- def teardown
- super
- $-w = @warn_before
- end
-
- def test_query_with_many_bind_params
- assert_equal [[nil, 1]], @db.query("select ?, ?", nil, 1).to_a
- end
-
- def test_query_with_nil_bind_params
- assert_equal [['foo']], @db.query("select 'foo'", nil).to_a
- end
-
- def test_execute_with_many_bind_params
- assert_equal [[nil, 1]], @db.execute("select ?, ?", nil, 1)
- end
-
- def test_execute_with_nil_bind_params
- assert_equal [['foo']], @db.execute("select 'foo'", nil)
- end
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/test/test_encoding.rb b/vendor/plugins/sqlite3-ruby/test/test_encoding.rb
deleted file mode 100644
index 107a0679..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_encoding.rb
+++ /dev/null
@@ -1,119 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'helper'
-
-module SQLite3
- class TestEncoding < Test::Unit::TestCase
- def setup
- @db = SQLite3::Database.new(':memory:')
- @create = "create table ex(id int, data string)"
- @insert = "insert into ex(id, data) values (?, ?)"
- @db.execute(@create);
- end
-
- def test_default_internal_is_honored
- warn_before = $-w
- $-w = false
-
- before_enc = Encoding.default_internal
-
- str = "壁に耳あり、障子に目あり"
- stmt = @db.prepare('insert into ex(data) values (?)')
- stmt.bind_param 1, str
- stmt.step
-
- Encoding.default_internal = 'EUC-JP'
- string = @db.execute('select data from ex').first.first
-
- assert_equal Encoding.default_internal, string.encoding
- assert_equal str.encode('EUC-JP'), string
- assert_equal str, string.encode(str.encoding)
- ensure
- Encoding.default_internal = before_enc
- $-w = warn_before
- end
-
- def test_blob_is_binary
- str = "猫舌"
- @db.execute('create table foo(data text)')
- stmt = @db.prepare('insert into foo(data) values (?)')
- stmt.bind_param(1, SQLite3::Blob.new(str))
- stmt.step
-
- string = @db.execute('select data from foo').first.first
- assert_equal Encoding.find('ASCII-8BIT'), string.encoding
- assert_equal str, string.force_encoding('UTF-8')
- end
-
- def test_blob_is_ascii8bit
- str = "猫舌"
- @db.execute('create table foo(data text)')
- stmt = @db.prepare('insert into foo(data) values (?)')
- stmt.bind_param(1, str.dup.force_encoding("ASCII-8BIT"))
- stmt.step
-
- string = @db.execute('select data from foo').first.first
- assert_equal Encoding.find('ASCII-8BIT'), string.encoding
- assert_equal str, string.force_encoding('UTF-8')
- end
-
- def test_blob_with_eucjp
- str = "猫舌".encode("EUC-JP")
- @db.execute('create table foo(data text)')
- stmt = @db.prepare('insert into foo(data) values (?)')
- stmt.bind_param(1, SQLite3::Blob.new(str))
- stmt.step
-
- string = @db.execute('select data from foo').first.first
- assert_equal Encoding.find('ASCII-8BIT'), string.encoding
- assert_equal str, string.force_encoding('EUC-JP')
- end
-
- def test_db_with_eucjp
- db = SQLite3::Database.new(':memory:'.encode('EUC-JP'))
- assert_equal(Encoding.find('UTF-8'), db.encoding)
- end
-
- def test_db_with_utf16
- db = SQLite3::Database.new(':memory:'.encode('UTF-16LE'))
- assert_equal(Encoding.find('UTF-16LE'), db.encoding)
- end
-
- def test_statement_eucjp
- str = "猫舌"
- @db.execute("insert into ex(data) values ('#{str}')".encode('EUC-JP'))
- row = @db.execute("select data from ex")
- assert_equal @db.encoding, row.first.first.encoding
- assert_equal str, row.first.first
- end
-
- def test_statement_utf8
- str = "猫舌"
- @db.execute("insert into ex(data) values ('#{str}')")
- row = @db.execute("select data from ex")
- assert_equal @db.encoding, row.first.first.encoding
- assert_equal str, row.first.first
- end
-
- def test_encoding
- assert_equal Encoding.find("UTF-8"), @db.encoding
- end
-
- def test_utf_8
- str = "猫舌"
- @db.execute(@insert, [10, str])
- row = @db.execute("select data from ex")
- assert_equal @db.encoding, row.first.first.encoding
- assert_equal str, row.first.first
- end
-
- def test_euc_jp
- str = "猫舌".encode('EUC-JP')
- @db.execute(@insert, [10, str])
- row = @db.execute("select data from ex")
- assert_equal @db.encoding, row.first.first.encoding
- assert_equal str.encode('UTF-8'), row.first.first
- end
-
- end if RUBY_VERSION >= '1.9.1'
-end
diff --git a/vendor/plugins/sqlite3-ruby/test/test_integration.rb b/vendor/plugins/sqlite3-ruby/test/test_integration.rb
deleted file mode 100644
index 3247e0fc..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_integration.rb
+++ /dev/null
@@ -1,545 +0,0 @@
-require 'helper'
-
-class TC_Database_Integration < Test::Unit::TestCase
- def setup
- @db = SQLite3::Database.new(":memory:")
- @db.transaction do
- @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' )"
- end
- end
-
- def teardown
- @db.close
- end
-
- def test_table_info_with_type_translation_active
- @db.type_translation = true
- assert_nothing_raised { @db.table_info("foo") }
- end
-
- def test_table_info_with_defaults_for_version_3_3_8_and_higher
- @db.transaction do
- @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello' )"
- data = @db.table_info( "defaults_test" )
- assert_equal({"name" => "a", "type" => "string", "dflt_value" => nil, "notnull" => 0, "cid" => 0, "pk" => 0},
- data[0])
- assert_equal({"name" => "b", "type" => "string", "dflt_value" => "Hello", "notnull" => 0, "cid" => 1, "pk" => 0},
- data[1])
- end
- end
-
- def test_table_info_without_defaults_for_version_3_3_8_and_higher
- @db.transaction do
- @db.execute "create table no_defaults_test ( a integer default 1, b integer )"
- data = @db.table_info( "no_defaults_test" )
- assert_equal({"name" => "a", "type" => "integer", "dflt_value" => "1", "notnull" => 0, "cid" => 0, "pk" => 0},
- data[0])
- assert_equal({"name" => "b", "type" => "integer", "dflt_value" => nil, "notnull" => 0, "cid" => 1, "pk" => 0},
- data[1])
- end
- end
-
- def test_complete_fail
- assert !@db.complete?( "select * from foo" )
- end
- def test_complete_success
- assert @db.complete?( "select * from foo;" )
- end
-
- # FIXME: do people really need UTF16 sql statements?
- #def test_complete_fail_utf16
- # assert !@db.complete?( "select * from foo".to_utf16(false), true )
- #end
-
- # FIXME: do people really need UTF16 sql statements?
- #def test_complete_success_utf16
- # assert @db.complete?( "select * from foo;".to_utf16(true), true )
- #end
-
- def test_errmsg
- assert_equal "not an error", @db.errmsg
- end
-
- # FIXME: do people really need UTF16 error messages?
- #def test_errmsg_utf16
- # msg = Iconv.conv('UTF-16', 'UTF-8', 'not an error')
- # assert_equal msg, @db.errmsg(true)
- #end
-
- def test_errcode
- assert_equal 0, @db.errcode
- end
-
- def test_trace
- result = nil
- @db.trace { |sql| result = sql }
- @db.execute "select * from foo"
- assert_equal "select * from foo", result
- end
-
- def test_authorizer_okay
- @db.authorizer { |type,a,b,c,d| 0 }
- rows = @db.execute "select * from foo"
- assert_equal 3, rows.length
- end
-
- def test_authorizer_error
- @db.authorizer { |type,a,b,c,d| 1 }
- assert_raise( SQLite3::AuthorizationException ) do
- @db.execute "select * from foo"
- end
- end
-
- def test_authorizer_silent
- @db.authorizer { |type,a,b,c,d| 2 }
- rows = @db.execute "select * from foo"
- assert rows.empty?
- end
-
- def test_prepare_invalid_syntax
- assert_raise( SQLite3::SQLException ) do
- @db.prepare "select from foo"
- end
- end
-
- def test_prepare_invalid_column
- assert_raise( SQLite3::SQLException ) do
- @db.prepare "select k from foo"
- end
- end
-
- def test_prepare_invalid_table
- assert_raise( SQLite3::SQLException ) do
- @db.prepare "select * from barf"
- end
- end
-
- def test_prepare_no_block
- stmt = @db.prepare "select * from foo"
- assert stmt.respond_to?(:execute)
- stmt.close
- end
-
- def test_prepare_with_block
- called = false
- @db.prepare "select * from foo" do |stmt|
- called = true
- assert stmt.respond_to?(:execute)
- end
- assert called
- end
-
- def test_execute_no_block_no_bind_no_match
- rows = @db.execute( "select * from foo where a > 100" )
- assert rows.empty?
- end
-
- def test_execute_with_block_no_bind_no_match
- called = false
- @db.execute( "select * from foo where a > 100" ) do |row|
- called = true
- end
- assert !called
- end
-
- def test_execute_no_block_with_bind_no_match
- rows = @db.execute( "select * from foo where a > ?", 100 )
- assert rows.empty?
- end
-
- def test_execute_with_block_with_bind_no_match
- called = false
- @db.execute( "select * from foo where a > ?", 100 ) do |row|
- called = true
- end
- assert !called
- end
-
- def test_execute_no_block_no_bind_with_match
- rows = @db.execute( "select * from foo where a = 1" )
- assert_equal 1, rows.length
- end
-
- def test_execute_with_block_no_bind_with_match
- called = 0
- @db.execute( "select * from foo where a = 1" ) do |row|
- called += 1
- end
- assert_equal 1, called
- end
-
- def test_execute_no_block_with_bind_with_match
- rows = @db.execute( "select * from foo where a = ?", 1 )
- assert_equal 1, rows.length
- end
-
- def test_execute_with_block_with_bind_with_match
- called = 0
- @db.execute( "select * from foo where a = ?", 1 ) do |row|
- called += 1
- end
- assert_equal 1, called
- end
-
- def test_execute2_no_block_no_bind_no_match
- columns, *rows = @db.execute2( "select * from foo where a > 100" )
- assert rows.empty?
- assert_equal [ "a", "b" ], columns
- end
-
- def test_execute2_with_block_no_bind_no_match
- called = 0
- @db.execute2( "select * from foo where a > 100" ) do |row|
- assert [ "a", "b" ], row unless called == 0
- called += 1
- end
- assert_equal 1, called
- end
-
- def test_execute2_no_block_with_bind_no_match
- columns, *rows = @db.execute2( "select * from foo where a > ?", 100 )
- assert rows.empty?
- assert_equal [ "a", "b" ], columns
- end
-
- def test_execute2_with_block_with_bind_no_match
- called = 0
- @db.execute2( "select * from foo where a > ?", 100 ) do |row|
- assert_equal [ "a", "b" ], row unless called == 0
- called += 1
- end
- assert_equal 1, called
- end
-
- def test_execute2_no_block_no_bind_with_match
- columns, *rows = @db.execute2( "select * from foo where a = 1" )
- assert_equal 1, rows.length
- assert_equal [ "a", "b" ], columns
- end
-
- def test_execute2_with_block_no_bind_with_match
- called = 0
- @db.execute2( "select * from foo where a = 1" ) do |row|
- assert_equal [ 1, "foo" ], row unless called == 0
- called += 1
- end
- assert_equal 2, called
- end
-
- def test_execute2_no_block_with_bind_with_match
- columns, *rows = @db.execute2( "select * from foo where a = ?", 1 )
- assert_equal 1, rows.length
- assert_equal [ "a", "b" ], columns
- end
-
- def test_execute2_with_block_with_bind_with_match
- called = 0
- @db.execute2( "select * from foo where a = ?", 1 ) do |row|
- called += 1
- end
- assert_equal 2, called
- end
-
- def test_execute_batch_empty
- assert_nothing_raised { @db.execute_batch "" }
- end
-
- def test_execute_batch_no_bind
- @db.transaction do
- @db.execute_batch <<-SQL
- create table bar ( a, b, c );
- insert into bar values ( 'one', 2, 'three' );
- insert into bar values ( 'four', 5, 'six' );
- insert into bar values ( 'seven', 8, 'nine' );
- SQL
- end
- rows = @db.execute( "select * from bar" )
- assert_equal 3, rows.length
- end
-
- def test_execute_batch_with_bind
- @db.execute_batch( <<-SQL, [1] )
- create table bar ( a, b, c );
- insert into bar values ( 'one', 2, ? );
- insert into bar values ( 'four', 5, ? );
- insert into bar values ( 'seven', 8, ? );
- SQL
- rows = @db.execute( "select * from bar" ).map { |a,b,c| c }
- assert_equal [1, 1, 1], rows
- end
-
- def test_query_no_block_no_bind_no_match
- result = @db.query( "select * from foo where a > 100" )
- assert_nil result.next
- result.close
- end
-
- def test_query_with_block_no_bind_no_match
- r = nil
- @db.query( "select * from foo where a > 100" ) do |result|
- assert_nil result.next
- r = result
- end
- assert r.closed?
- end
-
- def test_query_no_block_with_bind_no_match
- result = @db.query( "select * from foo where a > ?", 100 )
- assert_nil result.next
- result.close
- end
-
- def test_query_with_block_with_bind_no_match
- r = nil
- @db.query( "select * from foo where a > ?", 100 ) do |result|
- assert_nil result.next
- r = result
- end
- assert r.closed?
- end
-
- def test_query_no_block_no_bind_with_match
- result = @db.query( "select * from foo where a = 1" )
- assert_not_nil result.next
- assert_nil result.next
- result.close
- end
-
- def test_query_with_block_no_bind_with_match
- r = nil
- @db.query( "select * from foo where a = 1" ) do |result|
- assert_not_nil result.next
- assert_nil result.next
- r = result
- end
- assert r.closed?
- end
-
- def test_query_no_block_with_bind_with_match
- result = @db.query( "select * from foo where a = ?", 1 )
- assert_not_nil result.next
- assert_nil result.next
- result.close
- end
-
- def test_query_with_block_with_bind_with_match
- r = nil
- @db.query( "select * from foo where a = ?", 1 ) do |result|
- assert_not_nil result.next
- assert_nil result.next
- r = result
- end
- assert r.closed?
- end
-
- def test_get_first_row_no_bind_no_match
- result = @db.get_first_row( "select * from foo where a=100" )
- assert_nil result
- end
-
- def test_get_first_row_no_bind_with_match
- result = @db.get_first_row( "select * from foo where a=1" )
- assert_equal [ 1, "foo" ], result
- end
-
- def test_get_first_row_with_bind_no_match
- result = @db.get_first_row( "select * from foo where a=?", 100 )
- assert_nil result
- end
-
- def test_get_first_row_with_bind_with_match
- result = @db.get_first_row( "select * from foo where a=?", 1 )
- assert_equal [ 1, "foo" ], result
- end
-
- def test_get_first_value_no_bind_no_match
- result = @db.get_first_value( "select b, a from foo where a=100" )
- assert_nil result
- end
-
- def test_get_first_value_no_bind_with_match
- result = @db.get_first_value( "select b, a from foo where a=1" )
- assert_equal "foo", result
- end
-
- def test_get_first_value_with_bind_no_match
- result = @db.get_first_value( "select b, a from foo where a=?", 100 )
- assert_nil result
- end
-
- def test_get_first_value_with_bind_with_match
- result = @db.get_first_value( "select b, a from foo where a=?", 1 )
- assert_equal "foo", result
- end
-
- def test_last_insert_row_id
- @db.execute "insert into foo ( b ) values ( 'test' )"
- assert_equal 4, @db.last_insert_row_id
- @db.execute "insert into foo ( b ) values ( 'again' )"
- assert_equal 5, @db.last_insert_row_id
- end
-
- def test_changes
- @db.execute "insert into foo ( b ) values ( 'test' )"
- assert_equal 1, @db.changes
- @db.execute "delete from foo where 1=1"
- assert_equal 4, @db.changes
- end
-
- def test_total_changes
- assert_equal 3, @db.total_changes
- @db.execute "insert into foo ( b ) values ( 'test' )"
- @db.execute "delete from foo where 1=1"
- assert_equal 8, @db.total_changes
- end
-
- def test_transaction_nest
- assert_raise( SQLite3::SQLException ) do
- @db.transaction do
- @db.transaction do
- end
- end
- end
- end
-
- def test_transaction_rollback
- @db.transaction
- @db.execute_batch <<-SQL
- insert into foo (b) values ( 'test1' );
- insert into foo (b) values ( 'test2' );
- insert into foo (b) values ( 'test3' );
- insert into foo (b) values ( 'test4' );
- SQL
- assert_equal 7, @db.get_first_value("select count(*) from foo").to_i
- @db.rollback
- assert_equal 3, @db.get_first_value("select count(*) from foo").to_i
- end
-
- def test_transaction_commit
- @db.transaction
- @db.execute_batch <<-SQL
- insert into foo (b) values ( 'test1' );
- insert into foo (b) values ( 'test2' );
- insert into foo (b) values ( 'test3' );
- insert into foo (b) values ( 'test4' );
- SQL
- assert_equal 7, @db.get_first_value("select count(*) from foo").to_i
- @db.commit
- assert_equal 7, @db.get_first_value("select count(*) from foo").to_i
- end
-
- def test_transaction_rollback_in_block
- assert_raise( SQLite3::SQLException ) do
- @db.transaction do
- @db.rollback
- end
- end
- end
-
- def test_transaction_commit_in_block
- assert_raise( SQLite3::SQLException ) do
- @db.transaction do
- @db.commit
- end
- end
- end
-
- def test_transaction_active
- assert !@db.transaction_active?
- @db.transaction
- assert @db.transaction_active?
- @db.commit
- assert !@db.transaction_active?
- end
-
- def test_interrupt
- @db.create_function( "abort", 1 ) do |func,x|
- @db.interrupt
- func.result = x
- end
-
- assert_raise( SQLite3::InterruptException ) do
- @db.execute "select abort(a) from foo"
- end
- end
-
- def test_create_function
- @db.create_function( "munge", 1 ) do |func,x|
- func.result = ">>>#{x}<<<"
- end
-
- value = @db.get_first_value( "select munge(b) from foo where a=1" )
- assert_match( />>>.*<<= '1.9'
-
- busy = Mutex.new
- busy.lock
- handler_call_count = 0
-
- t = Thread.new(busy) do |locker|
- begin
- db2 = SQLite3::Database.open( "test.db" )
- db2.transaction( :exclusive ) do
- locker.lock
- end
- ensure
- db2.close if db2
- end
- end
-
- @db.busy_handler do |data,count|
- handler_call_count += 1
- busy.unlock
- true
- end
-
- assert_nothing_raised do
- @db.execute "insert into foo (b) values ( 'from 2' )"
- end
-
- t.join
-
- assert_equal 1, handler_call_count
- end
-
- def test_busy_handler_impatient
- busy = Mutex.new
- busy.lock
- handler_call_count = 0
-
- t = Thread.new do
- begin
- db2 = SQLite3::Database.open( "test.db" )
- db2.transaction( :exclusive ) do
- busy.lock
- end
- ensure
- db2.close if db2
- end
- end
- sleep 1
-
- @db.busy_handler do |count|
- handler_call_count += 1
- false
- end
-
- assert_raise( SQLite3::BusyException ) do
- @db.execute "insert into foo (b) values ( 'from 2' )"
- end
-
- busy.unlock
- t.join
-
- assert_equal 1, handler_call_count
- end
-
- def test_busy_timeout
- @db.busy_timeout 1000
- busy = Mutex.new
- busy.lock
-
- t = Thread.new do
- begin
- db2 = SQLite3::Database.open( "test.db" )
- db2.transaction( :exclusive ) do
- busy.lock
- end
- ensure
- db2.close if db2
- end
- end
-
- sleep 1
- time = Benchmark.measure do
- assert_raise( SQLite3::BusyException ) do
- @db.execute "insert into foo (b) values ( 'from 2' )"
- end
- end
-
- busy.unlock
- t.join
-
- assert time.real*1000 >= 1000
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/test/test_integration_resultset.rb b/vendor/plugins/sqlite3-ruby/test/test_integration_resultset.rb
deleted file mode 100644
index 5274fc90..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_integration_resultset.rb
+++ /dev/null
@@ -1,183 +0,0 @@
-require 'helper'
-
-class TC_ResultSet < Test::Unit::TestCase
- def setup
- @db = SQLite3::Database.new(":memory:")
- @db.transaction do
- @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' )"
- end
- @stmt = @db.prepare( "select * from foo where a in ( ?, ? )" )
- @result = @stmt.execute
- end
-
- def teardown
- @stmt.close
- @db.close
- end
-
- def test_reset_unused
- assert_nothing_raised { @result.reset }
- assert @result.to_a.empty?
- end
-
- def test_reset_used
- @result.to_a
- assert_nothing_raised { @result.reset }
- assert @result.to_a.empty?
- end
-
- def test_reset_with_bind
- @result.to_a
- assert_nothing_raised { @result.reset( 1, 2 ) }
- assert_equal 2, @result.to_a.length
- end
-
- def test_eof_inner
- @result.reset( 1 )
- assert !@result.eof?
- end
-
- def test_eof_edge
- @result.reset( 1 )
- @result.next # to first row
- @result.next # to end of result set
- assert @result.eof?
- end
-
- def test_next_eof
- @result.reset( 1 )
- assert_not_nil @result.next
- assert_nil @result.next
- end
-
- def test_next_no_type_translation_no_hash
- @result.reset( 1 )
- assert_equal [ 1, "foo" ], @result.next
- end
-
- def test_next_type_translation
- @db.type_translation = true
- @result.reset( 1 )
- assert_equal [ 1, "foo" ], @result.next
- end
-
- def test_next_type_translation_with_untyped_column
- @db.type_translation = true
- @db.query( "select count(*) from foo" ) do |result|
- assert_equal [3], result.next
- end
- end
-
- def test_type_translation_execute
- @db.type_translation = true
- @db.execute "create table bar ( a integer, b america )"
- @db.execute "insert into bar (a, b) values (NULL, '1974-07-25 14:39:00')"
-
- @db.translator.add_translator('america') do |type, thing|
- 'america'
- end
-
- assert_equal [[nil, 'america']], @db.execute("select * from bar")
- end
-
- def test_type_translation_with_null_column
- @db.type_translation = true
- @db.execute "create table bar ( a integer, b time, c string )"
- @db.execute "insert into bar (a, b, c) values (NULL, '1974-07-25 14:39:00', 'hello')"
- @db.execute "insert into bar (a, b, c) values (1, NULL, 'hello')"
- @db.execute "insert into bar (a, b, c) values (2, '1974-07-25 14:39:00', NULL)"
- @db.query( "select * from bar" ) do |result|
- assert_equal [nil, Time.local(1974, 7, 25, 14, 39, 0), 'hello'], result.next
- assert_equal [1, nil, 'hello'], result.next
- assert_equal [2, Time.local(1974, 7, 25, 14, 39, 0), nil], result.next
- end
- end
-
- def test_date_and_time_translation
- @db.type_translation = true
- @db.execute "create table bar ( a date, b datetime, c time, d timestamp )"
- @db.execute "insert into bar (a, b, c, d) values ('1999-01-08', '1997-12-17 07:37:16', '07:37:16', '2004-10-19 10:23:54')"
- @db.query( "select * from bar" ) do |result|
- result = result.next
- assert result[0].is_a?(Date)
- assert result[1].is_a?(DateTime)
- assert result[2].is_a?(Time)
- assert result[3].is_a?(Time)
- end
- end
-
- def test_real_translation
- @db.type_translation = true
- @db.execute('create table foo_real(a real)')
- @db.execute('insert into foo_real values (42)' )
- @db.query('select a, sum(a), typeof(a), typeof(sum(a)) from foo_real') do |result|
- result = result.next
- assert result[0].is_a?(Float)
- assert result[1].is_a?(Float)
- assert result[2].is_a?(String)
- assert result[3].is_a?(String)
- end
- end
-
- def test_next_results_as_hash
- @db.results_as_hash = true
- @result.reset( 1 )
- assert_equal( { "a" => 1, "b" => "foo", 0 => 1, 1 => "foo" },
- @result.next )
- end
-
- def test_tainted_results_as_hash
- @db.results_as_hash = true
- @result.reset( 1 )
- row = @result.next
- row.each do |_, v|
- assert(v.tainted?) if String === v
- end
- end
-
- def test_tainted_row_values
- @result.reset( 1 )
- row = @result.next
- row.each do |v|
- assert(v.tainted?) if String === v
- end
- end
-
- def test_each
- called = 0
- @result.reset( 1, 2 )
- @result.each { |row| called += 1 }
- assert_equal 2, called
- end
-
- def test_enumerable
- @result.reset( 1, 2 )
- assert_equal 2, @result.to_a.length
- end
-
- def test_types
- assert_equal [ "integer", "text" ], @result.types
- end
-
- def test_columns
- assert_equal [ "a", "b" ], @result.columns
- end
-
- def test_close
- stmt = @db.prepare( "select * from foo" )
- result = stmt.execute
- assert !result.closed?
- result.close
- assert result.closed?
- assert stmt.closed?
- assert_raise( SQLite3::Exception ) { result.reset }
- assert_raise( SQLite3::Exception ) { result.next }
- assert_raise( SQLite3::Exception ) { result.each }
- assert_raise( SQLite3::Exception ) { result.close }
- assert_raise( SQLite3::Exception ) { result.types }
- assert_raise( SQLite3::Exception ) { result.columns }
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/test/test_integration_statement.rb b/vendor/plugins/sqlite3-ruby/test/test_integration_statement.rb
deleted file mode 100644
index 9f7cde54..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_integration_statement.rb
+++ /dev/null
@@ -1,194 +0,0 @@
-require File.join(File.dirname(__FILE__), 'helper')
-
-class TC_Statement < Test::Unit::TestCase
- def setup
- @db = SQLite3::Database.new(":memory:")
- @db.transaction do
- @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' )"
- end
- @stmt = @db.prepare( "select * from foo where a in ( ?, :named )" )
- end
-
- def teardown
- @stmt.close
- @db.close
- end
-
- def test_remainder_empty
- assert_equal "", @stmt.remainder
- end
-
- def test_remainder_nonempty
- called = false
- @db.prepare( "select * from foo;\n blah" ) do |stmt|
- called = true
- assert_equal "\n blah", stmt.remainder
- end
- assert called
- end
-
- def test_bind_params_empty
- assert_nothing_raised { @stmt.bind_params }
- assert @stmt.execute!.empty?
- end
-
- def test_bind_params_array
- @stmt.bind_params 1, 2
- assert_equal 2, @stmt.execute!.length
- end
-
- def test_bind_params_hash
- @stmt.bind_params ":named" => 2
- assert_equal 1, @stmt.execute!.length
- end
-
- def test_bind_params_hash_without_colon
- @stmt.bind_params "named" => 2
- assert_equal 1, @stmt.execute!.length
- end
-
- def test_bind_params_hash_as_symbol
- @stmt.bind_params :named => 2
- assert_equal 1, @stmt.execute!.length
- end
-
- def test_bind_params_mixed
- @stmt.bind_params( 1, ":named" => 2 )
- assert_equal 2, @stmt.execute!.length
- end
-
- def test_bind_param_by_index
- @stmt.bind_params( 1, 2 )
- assert_equal 2, @stmt.execute!.length
- end
-
- def test_bind_param_by_name_bad
- assert_raise( SQLite3::Exception ) { @stmt.bind_param( "@named", 2 ) }
- end
-
- def test_bind_param_by_name_good
- @stmt.bind_param( ":named", 2 )
- assert_equal 1, @stmt.execute!.length
- end
-
- def test_bind_param_with_various_types
- @db.transaction do
- @db.execute "create table all_types ( a integer primary key, b float, c string, d integer )"
- @db.execute "insert into all_types ( b, c, d ) values ( 1.4, 'hello', 68719476735 )"
- end
-
- assert_equal 1, @db.execute( "select * from all_types where b = ?", 1.4 ).length
- assert_equal 1, @db.execute( "select * from all_types where c = ?", 'hello').length
- assert_equal 1, @db.execute( "select * from all_types where d = ?", 68719476735).length
- end
-
- def test_execute_no_bind_no_block
- assert_instance_of SQLite3::ResultSet, @stmt.execute
- end
-
- def test_execute_with_bind_no_block
- assert_instance_of SQLite3::ResultSet, @stmt.execute( 1, 2 )
- end
-
- def test_execute_no_bind_with_block
- called = false
- @stmt.execute { |row| called = true }
- assert called
- end
-
- def test_execute_with_bind_with_block
- called = 0
- @stmt.execute( 1, 2 ) { |row| called += 1 }
- assert_equal 1, called
- end
-
- def test_reexecute
- r = @stmt.execute( 1, 2 )
- assert_equal 2, r.to_a.length
- assert_nothing_raised { r = @stmt.execute( 1, 2 ) }
- assert_equal 2, r.to_a.length
- end
-
- def test_execute_bang_no_bind_no_block
- assert @stmt.execute!.empty?
- end
-
- def test_execute_bang_with_bind_no_block
- assert_equal 2, @stmt.execute!( 1, 2 ).length
- end
-
- def test_execute_bang_no_bind_with_block
- called = 0
- @stmt.execute! { |row| called += 1 }
- assert_equal 0, called
- end
-
- def test_execute_bang_with_bind_with_block
- called = 0
- @stmt.execute!( 1, 2 ) { |row| called += 1 }
- assert_equal 2, called
- end
-
- def test_columns
- c1 = @stmt.columns
- c2 = @stmt.columns
- assert_same c1, c2
- assert_equal 2, c1.length
- end
-
- def test_columns_computed
- called = false
- @db.prepare( "select count(*) from foo" ) do |stmt|
- called = true
- assert_equal [ "count(*)" ], stmt.columns
- end
- assert called
- end
-
- def test_types
- t1 = @stmt.types
- t2 = @stmt.types
- assert_same t1, t2
- assert_equal 2, t1.length
- end
-
- def test_types_computed
- called = false
- @db.prepare( "select count(*) from foo" ) do |stmt|
- called = true
- assert_equal [ nil ], stmt.types
- end
- assert called
- end
-
- def test_close
- stmt = @db.prepare( "select * from foo" )
- assert !stmt.closed?
- stmt.close
- assert stmt.closed?
- assert_raise( SQLite3::Exception ) { stmt.execute }
- assert_raise( SQLite3::Exception ) { stmt.execute! }
- assert_raise( SQLite3::Exception ) { stmt.close }
- assert_raise( SQLite3::Exception ) { stmt.bind_params 5 }
- assert_raise( SQLite3::Exception ) { stmt.bind_param 1, 5 }
- assert_raise( SQLite3::Exception ) { stmt.columns }
- assert_raise( SQLite3::Exception ) { stmt.types }
- end
-
- def test_committing_tx_with_statement_active
- called = false
- @db.prepare( "select count(*) from foo" ) do |stmt|
- called = true
- count = stmt.execute!.first.first.to_i
- @db.transaction do
- @db.execute "insert into foo ( b ) values ( 'hello' )"
- end
- new_count = stmt.execute!.first.first.to_i
- assert_equal new_count, count+1
- end
- assert called
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/test/test_sqlite3.rb b/vendor/plugins/sqlite3-ruby/test/test_sqlite3.rb
deleted file mode 100644
index d28ef64a..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_sqlite3.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-require 'helper'
-
-module SQLite3
- class TestSQLite3 < Test::Unit::TestCase
- def test_libversion
- assert_not_nil SQLite3.libversion
- end
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/test/test_statement.rb b/vendor/plugins/sqlite3-ruby/test/test_statement.rb
deleted file mode 100644
index fa1f3ffa..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_statement.rb
+++ /dev/null
@@ -1,207 +0,0 @@
-require 'helper'
-
-module SQLite3
- class TestStatement < Test::Unit::TestCase
- def setup
- @db = SQLite3::Database.new(':memory:')
- @stmt = SQLite3::Statement.new(@db, "select 'foo'")
- 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
- end
-end
diff --git a/vendor/plugins/sqlite3-ruby/test/test_statement_execute.rb b/vendor/plugins/sqlite3-ruby/test/test_statement_execute.rb
deleted file mode 100644
index 68da36d6..00000000
--- a/vendor/plugins/sqlite3-ruby/test/test_statement_execute.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-require 'helper'
-
-module SQLite3
- class TestStatementExecute < Test::Unit::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
![[+]](./images/find.png "show/hide quicksearch")
![[+]](../images/find.png "show/hide quicksearch"){kind=small}
![[+]](../../images/find.png "show/hide quicksearch"){kind=small}
![[+]](../../../images/find.png "show/hide quicksearch"){kind=small}