amalgalite 0.7.4 → 0.7.5

data/HISTORY

@@ -1,4 +1,11 @@
 = Amalgalite Changelog
+== Version 0.7.5 - 2009-02-12
+
+=== Bug Fixes
+
+* another ruby -w pass to clear up warnings
+* force all tests to run with -w turned on
+
 == Version 0.7.4 - 2009-02-08
 
 === Bug Fixes

data/lib/amalgalite/boolean.rb

@@ -30,7 +30,7 @@ module Amalgalite
       #
       def to_bool( val )
         return false if val.nil?
-        unless @to_bool
+        unless defined? @to_bool
           @to_bool = {}
           true_values.each  { |t| @to_bool[t] = true  }
           false_values.each { |f| @to_bool[f] = false }

data/lib/amalgalite/database.rb

@@ -212,10 +212,7 @@ module Amalgalite
     # return the encoding of the database
     #
     def encoding
-      unless @encoding
-        @encoding = pragma( "encoding" ).first['encoding']
-      end
-      return @encoding
+      @encoding ||= pragma( "encoding" ).first['encoding']
     end
 
     ## 

data/lib/amalgalite/paths.rb

@@ -11,50 +11,50 @@ module Amalgalite
     #
     # The root directory of the project is considered to be the parent directory
     # of the 'lib' directory.
-    #   
+    #
     # returns:: [String] The full expanded path of the parent directory of 'lib'
     #           going up the path from the current file.  Trailing
     #           File::SEPARATOR is guaranteed.
-    #   
+    #
     def self.root_dir
-      unless @root_dir
+      @root_dir ||= (
         path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
         lib_index  = path_parts.rindex("lib")
-        @root_dir = path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
-      end 
+        path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
+      )
       return @root_dir
-    end 
+    end
 
     # returns:: [String] The full expanded path of the +config+ directory
     #           below _root_dir_.  All parameters passed in are joined onto the
     #           result.  Trailing File::SEPARATOR is guaranteed if _args_ are
     #           *not* present.
-    #   
+    #
     def self.config_path(*args)
       self.sub_path("config", *args)
-    end 
+    end
 
     # returns:: [String] The full expanded path of the +data+ directory below
-    #           _root_dir_.  All parameters passed in are joined onto the 
-    #           result. Trailing File::SEPARATOR is guaranteed if 
+    #           _root_dir_.  All parameters passed in are joined onto the
+    #           result. Trailing File::SEPARATOR is guaranteed if
     #           _*args_ are *not* present.
-    #   
+    #
     def self.data_path(*args)
       self.sub_path("data", *args)
-    end 
+    end
 
     # returns:: [String] The full expanded path of the +lib+ directory below
-    #           _root_dir_.  All parameters passed in are joined onto the 
-    #           result. Trailing File::SEPARATOR is guaranteed if 
+    #           _root_dir_.  All parameters passed in are joined onto the
+    #           result. Trailing File::SEPARATOR is guaranteed if
     #           _*args_ are *not* present.
-    #   
+    #
     def self.lib_path(*args)
       self.sub_path("lib", *args)
-    end 
+    end
 
     # returns:: [String] The full expanded path of the +ext+ directory below
-    #           _root_dir_.  All parameters passed in are joined onto the 
-    #           result. Trailing File::SEPARATOR is guaranteed if 
+    #           _root_dir_.  All parameters passed in are joined onto the
+    #           result. Trailing File::SEPARATOR is guaranteed if
     #           _*args_ are *not* present.
     #
     def self.ext_path(*args)

data/lib/amalgalite/sqlite3/constants.rb

@@ -12,7 +12,7 @@ module Amalgalite::SQLite3
       # constant. this is a helper method used by some of the other modules
       #
       def name_from_value( value )
-        unless @const_map_from_value
+        unless defined? @const_map_from_value
           @const_map_from_value = {}
           constants.each do |const_name|
             c_int = const_get( const_name )
@@ -27,7 +27,7 @@ module Amalgalite::SQLite3
       # some of the other modules
       #
       def value_from_name( name )
-        unless @const_map_from_name
+        unless defined? @const_map_from_name
           @const_map_from_name = {}
           constants.each do |const_name|
             c_int = const_get( const_name )

data/lib/amalgalite/type_maps/default_map.rb

@@ -34,7 +34,7 @@ module Amalgalite::TypeMaps
       # say what method to call to convert an sql type to a ruby type
       #
       def sql_to_method( sql_type  ) # :nodoc:
-        unless @sql_to_method
+        unless defined? @sql_to_method
           @sql_to_method = {}
           methods_handling_sql_types.each_pair do |method, sql_types|
             sql_types.each { |t| @sql_to_method[t] = method }

data/lib/amalgalite/version.rb

@@ -9,7 +9,7 @@ module Amalgalite
 
     MAJOR   = 0
     MINOR   = 7
-    BUILD   = 4
+    BUILD   = 5
 
     #
     # return the Version as an array of MAJOR, MINOR, BUILD

data/spec/aggregate_spec.rb

@@ -43,29 +43,29 @@ describe "Aggregate SQL Functions" do
   it "can define a custom SQL aggregate as a class with N params" do
     @iso_db.define_aggregate("atest1", AggregateTest1 )
     r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
-    r.first['a'].should == r.first['c']
-    r.first['a'].should == 242
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
   end
 
   it "can remove a custom SQL aggregate by class" do
     @iso_db.define_aggregate("atest1", AggregateTest1 )
-    @iso_db.aggregates.size.should == 1
+    @iso_db.aggregates.size.should eql(1)
     r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
-    r.first['a'].should == r.first['c']
-    r.first['a'].should == 242
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
     @iso_db.remove_aggregate( "atest1", AggregateTest1 )
-    @iso_db.aggregates.size.should == 0
+    @iso_db.aggregates.size.should eql(0)
     lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
   end
 
   it "can remove a custom SQL aggregate by arity" do
     @iso_db.define_aggregate("atest1", AggregateTest1 )
-    @iso_db.aggregates.size.should == 1
+    @iso_db.aggregates.size.should eql(1)
     r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
-    r.first['a'].should == r.first['c']
-    r.first['a'].should == 242
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
     @iso_db.remove_aggregate( "atest1", -1)
-    @iso_db.aggregates.size.should == 0
+    @iso_db.aggregates.size.should eql(0)
     lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
   end
 
@@ -75,12 +75,12 @@ describe "Aggregate SQL Functions" do
     end
     @iso_db.define_aggregate("atest1", AggregateTest1 )
     @iso_db.define_aggregate("atest1", AT2)
-    @iso_db.aggregates.size.should == 2
+    @iso_db.aggregates.size.should eql(2)
     r = @iso_db.execute("SELECT atest1(id,name) as a, atest1(id), count(*) as c FROM country")
-    r.first['a'].should == r.first['c']
-    r.first['a'].should == 242
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
     @iso_db.remove_aggregate( "atest1" )
-    @iso_db.aggregates.size.should == 0
+    @iso_db.aggregates.size.should eql(0)
     lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
   end
 

data/spec/blob_spec.rb

@@ -46,27 +46,27 @@ describe Amalgalite::Blob do
 
       it "and retrieves the data as a single value" do
         all_rows = @db.execute("SELECT name,data FROM blobs")
-        all_rows.size.should == 1;
-        all_rows.first['name'].should == DATA_FILE
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(DATA_FILE)
         all_rows.first['data'].should_not be_incremental
-        all_rows.first['data'].to_string_io.string.should == IO.read( DATA_FILE )
+        all_rows.first['data'].to_string_io.string.should eql(IO.read( DATA_FILE ))
       end
 
       it "and retrieves the data using incremental IO" do
         all_rows = @db.execute("SELECT * FROM blobs")
-        all_rows.size.should == 1;
-        all_rows.first['name'].should == DATA_FILE
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(DATA_FILE)
         all_rows.first['data'].should be_incremental
-        all_rows.first['data'].to_string_io.string.should == IO.read( DATA_FILE )
+        all_rows.first['data'].to_string_io.string.should eql(IO.read( DATA_FILE ))
       end
 
       it "writes the data to a file " do
         all_rows = @db.execute("SELECT * FROM blobs")
-        all_rows.size.should == 1;
-        all_rows.first['name'].should == DATA_FILE
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(DATA_FILE)
         all_rows.first['data'].should be_incremental
         all_rows.first['data'].write_to_file( @junk_file )
-        IO.read( @junk_file).should == IO.read( DATA_FILE )
+        IO.read( @junk_file).should eql(IO.read( DATA_FILE ))
       end
     end
   end

data/spec/database_spec.rb

@@ -25,14 +25,14 @@ describe Amalgalite::Database do
     db = Amalgalite::Database.new( SpecInfo.test_db )
     db.instance_of?(Amalgalite::Database) 
     db.api.instance_of?(Amalgalite::SQLite3::Database) 
-    File.exist?( SpecInfo.test_db ).should == true
+    File.exist?( SpecInfo.test_db ).should eql(true)
   end
 
   it "creates a new UTF-8 database (need exec to check pragma encoding)" do
     db = Amalgalite::Database.new( SpecInfo.test_db )
     db.execute_batch( @schema );
     db.should_not be_utf16
-    db.encoding.should == "UTF-8"
+    db.encoding.should eql("UTF-8")
   end
 
   it "creates a new UTF-16 database (need exec to check pragma encoding)" 
@@ -47,15 +47,15 @@ describe Amalgalite::Database do
   end
 
   it "can be in autocommit mode, and is by default" do
-    @iso_db.autocommit?.should == true
+    @iso_db.autocommit?.should eql(true)
   end
 
   it "reports false for autocommit? when inside a transaction" do
     @iso_db.execute(" BEGIN ")
-    @iso_db.autocommit?.should == false
-    @iso_db.in_transaction?.should == true
+    @iso_db.autocommit?.should eql(false)
+    @iso_db.in_transaction?.should eql(true)
     @iso_db.execute(" COMMIT")
-    @iso_db.in_transaction?.should == false
+    @iso_db.in_transaction?.should eql(false)
   end
 
   it "prepares a statment" do
@@ -77,7 +77,7 @@ describe Amalgalite::Database do
 
   it "returns the id of the last inserted row" do
     db = Amalgalite::Database.new( SpecInfo.test_db )
-    db.last_insert_rowid.should == 0
+    db.last_insert_rowid.should eql(0)
   end
 
   it "is in autocommit mode by default" do
@@ -94,8 +94,8 @@ describe Amalgalite::Database do
       INSERT INTO t1( x ) values ( 3 );
     sql
 
-    db.row_changes.should == 1
-    db.total_changes.should == 3
+    db.row_changes.should eql(1)
+    db.total_changes.should eql(3)
     db.close
   end
 
@@ -108,7 +108,7 @@ describe Amalgalite::Database do
       INSERT INTO t1( x ) values ( 3 );
       DELETE FROM t1 where x < 3;
     sql
-    db.row_changes.should == 2
+    db.row_changes.should eql(2)
     db.close
   end
 
@@ -119,7 +119,7 @@ describe Amalgalite::Database do
 
   it "can execute a batch of commands" do
     db = Amalgalite::Database.new( SpecInfo.test_db )
-    db.execute_batch( @schema ).should == 5
+    db.execute_batch( @schema ).should eql(5)
   end
 
   it "returns an empty array when there are no results" do
@@ -132,9 +132,9 @@ describe Amalgalite::Database do
     sql = "CREATE TABLE trace_test( x, y, z)"
     s = db.trace_tap = ::Amalgalite::Taps::StringIO.new
     db.execute( sql )
-    db.trace_tap.string.should== "registered as trace tap\n#{sql}\n"
+    db.trace_tap.string.should eql("registered as trace tap\n#{sql}\n")
     db.trace_tap = nil
-    s.string.should== "registered as trace tap\n#{sql}\nunregistered as trace tap\n"
+    s.string.should eql("registered as trace tap\n#{sql}\nunregistered as trace tap\n")
   end
 
   it "raises an exception if the wrong type of object is used for tracing" do
@@ -151,7 +151,7 @@ describe Amalgalite::Database do
     db = Amalgalite::Database.new( SpecInfo.test_db )
     s = db.profile_tap = ::Amalgalite::Taps::StringIO.new
     db.execute_batch( @schema )
-    db.profile_tap.samplers.size.should == 6
+    db.profile_tap.samplers.size.should eql(6)
     db.profile_tap = nil
     s.string.should =~ /unregistered as profile tap/m
   end
@@ -161,7 +161,7 @@ describe Amalgalite::Database do
     @iso_db.execute( "SELECT * FROM country LIMIT 10") do |row|
       count += 1
     end
-    count.should == 10
+    count.should eql(10)
   end
 
   it "#pragma yields each row when called with a block" do
@@ -169,13 +169,13 @@ describe Amalgalite::Database do
     @iso_db.pragma( "index_info( subcountry_country )" ) do |row|
       count += 1
     end
-    count.should == 1
+    count.should eql(1)
   end
 
   it "can use something that responds to 'write' as a tap" do
     db = Amalgalite::Database.new( SpecInfo.test_db )
     s2 = db.trace_tap   = StringIO.new
-    s2.string.should == "registered as trace tap"
+    s2.string.should eql("registered as trace tap")
   end
 
   it "can clear all registered taps" do
@@ -183,7 +183,7 @@ describe Amalgalite::Database do
     s = db.profile_tap = ::Amalgalite::Taps::StringIO.new
     db.trace_tap = s
     db.execute_batch( @schema )
-    db.profile_tap.samplers.size.should == 6
+    db.profile_tap.samplers.size.should eql(6)
     db.clear_taps!
     s.string.should =~ /unregistered as trace tap/m
     s.string.should =~ /unregistered as profile tap/m
@@ -193,50 +193,50 @@ describe Amalgalite::Database do
     db = Amalgalite::Database.new( SpecInfo.test_db )
     r = db.transaction do |db2|
       r2 = db.transaction { 42 }
-      r2.should == 42
+      r2.should eql(42)
       r2
     end
-    r.should == 42
+    r.should eql(42)
   end
 
   it "returns the result of the transaction when a block is yielded" do
     db = Amalgalite::Database.new( SpecInfo.test_db )
-    (db.transaction { 42 }).should == 42
+    (db.transaction { 42 }).should eql(42)
   end
 
   it "#reload_schema!" do
     @iso_db = Amalgalite::Database.new( SpecInfo.make_iso_db )
     schema = @iso_db.schema
-    schema.instance_of?( Amalgalite::Schema ).should == true
+    schema.instance_of?( Amalgalite::Schema ).should eql(true)
     s2 = @iso_db.reload_schema!
-    s2.object_id.should_not == schema.object_id
+    s2.object_id.should_not eql(schema.object_id)
   end
 
   it "can rollback a transaction" do
     @iso_db.transaction 
     r = @iso_db.execute("SELECT count(1) as cnt FROM country");
-    r.first['cnt'].should == 242
+    r.first['cnt'].should eql(242)
     @iso_db.execute("DELETE FROM country")
     r = @iso_db.execute("SELECT count(1) as cnt FROM country");
-    r.first['cnt'].should == 0
+    r.first['cnt'].should eql(0)
     @iso_db.rollback
 
     r = @iso_db.execute("SELECT count(1) as cnt FROM country");
-    r.first['cnt'].should == 242
+    r.first['cnt'].should eql(242)
   end
 
   it "rolls back if an exception happens during a transaction block" do
     begin
       @iso_db.transaction do |db|
         r = db.execute("SELECT count(1) as cnt FROM country");
-        r.first['cnt'].should == 242
+        r.first['cnt'].should eql(242)
         db.execute("DELETE FROM country")
-        db.in_transaction?.should == true
+        db.in_transaction?.should eql(true)
         raise "testing rollback"
       end
     rescue => e
-      @iso_db.in_transaction?.should == false
-      @iso_db.execute("SELECT count(1) as cnt FROM country").first['cnt'].should == 242
+      @iso_db.in_transaction?.should eql(false)
+      @iso_db.execute("SELECT count(1) as cnt FROM country").first['cnt'].should eql(242)
     end
   end
 
@@ -268,13 +268,13 @@ describe Amalgalite::Database do
       @iso_db.define_function( "rtest" ) do
         "rtest called"
       end
-      @iso_db.functions.size.should == 1 
+      @iso_db.functions.size.should eql(1 )
 
       r = @iso_db.execute( "select rtest() AS r" )
-      r.first['r'].should == "rtest called"
+      r.first['r'].should eql("rtest called")
       @iso_db.remove_function("rtest", -1)
       lambda { @iso_db.execute( "select rtest() as r" )}.should raise_error( ::Amalgalite::SQLite3::Error, /no such function: rtest/ )
-      @iso_db.functions.size.should == 0
+      @iso_db.functions.size.should eql(0)
     end
 
     it "unregisters a function by instances" do
@@ -285,12 +285,12 @@ describe Amalgalite::Database do
         def call( *args) "ftest5 called"; end
       end
       @iso_db.define_function("ftest5", FunctionTest5.new )
-      @iso_db.functions.size.should == 1
+      @iso_db.functions.size.should eql(1)
       r = @iso_db.execute( "select ftest5() AS r" )
-      r.first['r'].should == "ftest5 called"
+      r.first['r'].should eql("ftest5 called")
       @iso_db.remove_function("ftest5", FunctionTest5.new )
       lambda { @iso_db.execute( "select ftest5() as r" )}.should raise_error( ::Amalgalite::SQLite3::Error, /no such function: ftest5/ )
-      @iso_db.functions.size.should == 0
+      @iso_db.functions.size.should eql(0)
     end
 
     it "unregisters all functions with the same name" do
@@ -302,15 +302,15 @@ describe Amalgalite::Database do
         "rtest/0 called"
       end
 
-      @iso_db.functions.size.should == 2
+      @iso_db.functions.size.should eql(2)
       r = @iso_db.execute( "select rtest(1) AS r")
-      r.first['r'].should == "rtest 1 called"
+      r.first['r'].should eql("rtest 1 called")
       r = @iso_db.execute( "select rtest() AS r")
-      r.first['r'].should == "rtest/0 called"
+      r.first['r'].should eql("rtest/0 called")
       @iso_db.remove_function( 'rtest' )
       lambda {  @iso_db.execute( "select rtest(1) AS r") }.should raise_error( ::Amalgalite::SQLite3::Error )
       lambda {  @iso_db.execute( "select rtest() AS r")  }.should raise_error( ::Amalgalite::SQLite3::Error )
-      @iso_db.functions.size.should == 0
+      @iso_db.functions.size.should eql(0)
     end
   end
 
@@ -349,7 +349,7 @@ describe Amalgalite::Database do
 
   it "releases a savepoint" do
     us_sub = @iso_db.execute( "select count(1) as cnt from subcountry where country = 'US'" ).first['cnt']
-    us_sub.should == 57
+    us_sub.should eql(57)
     other_sub = @iso_db.execute( "select count(1) as cnt from subcountry where country != 'US'" ).first['cnt']
 
     @iso_db.transaction
@@ -359,10 +359,10 @@ describe Amalgalite::Database do
 
     all_sub = @iso_db.execute("SELECT count(*) as cnt from subcountry").first['cnt']
 
-    all_sub.should == other_sub;
+    all_sub.should eql(other_sub)
     @iso_db.rollback
     all_sub = @iso_db.execute("SELECT count(*) as cnt from subcountry").first['cnt']
-    all_sub.should == ( us_sub + other_sub )
+    all_sub.should eql(( us_sub + other_sub ))
 
   end
 
@@ -375,7 +375,7 @@ describe Amalgalite::Database do
       end
     }.should raise_error( StandardError, /sample error/ )
 
-    @iso_db.execute("SELECT count(*) as cnt from subcountry").first['cnt'].should == all_sub
+    @iso_db.execute("SELECT count(*) as cnt from subcountry").first['cnt'].should eql(all_sub)
   end
 
   it "rolling back the outermost savepoint is still 'in_transaction'" do
@@ -388,19 +388,19 @@ describe Amalgalite::Database do
   end
 
   it "can escape quoted strings" do
-    @iso_db.escape( "It's a happy day!" ).should == "It''s a happy day!"
+    @iso_db.escape( "It's a happy day!" ).should eql("It''s a happy day!")
   end
 
   it "can quote and escape single quoted strings" do
-    @iso_db.quote( "It's a happy day!" ).should == "'It''s a happy day!'"
+    @iso_db.quote( "It's a happy day!" ).should eql("'It''s a happy day!'")
   end
 
   it "can escape a symbol" do
-    @iso_db.escape( :stuff ).should == "stuff"
+    @iso_db.escape( :stuff ).should eql("stuff")
   end
   
   it "can quote a symbol" do
-    @iso_db.quote( :stuff ).should == "'stuff'"
+    @iso_db.quote( :stuff ).should eql("'stuff'")
   end
 
   it "returns the first row of results as a convenience" do
@@ -410,13 +410,13 @@ describe Amalgalite::Database do
                                        ON c.two_letter  = sc.country 
                                  GROUP BY c.name, c.two_letter
                                  ORDER BY count DESC")
-    row.length.should == 3
-    row[0].should == "United Kingdom"
-    row[1].should == "GB"
-    row[2].should == 232
-    row['name'].should == "United Kingdom"
-    row['two_letter'].should == "GB"
-    row['count'].should == 232
+    row.length.should eql(3)
+    row[0].should eql("United Kingdom")
+    row[1].should eql("GB")
+    row[2].should eql(232)
+    row['name'].should eql("United Kingdom")
+    row['two_letter'].should eql("GB")
+    row['count'].should eql(232)
   end
 
   it "returns and empty row if there are no results for the first row" do
@@ -426,12 +426,12 @@ describe Amalgalite::Database do
 
   it "returns nil if there is no value in the first value" do
     val = @iso_db.first_value_from("select * from subcountry where country = 'Antarctica'" )
-    val.should == nil
+    val.should eql(nil)
   end
 
   it "returns the first value of results as a conveinience" do
     val = @iso_db.first_value_from("SELECT count(*) from subcountry ")
-    val.should == 3995
+    val.should eql(3995)
   end
 
 end

data/spec/integeration_spec.rb

@@ -50,12 +50,12 @@ describe "Integration specifications" do
         db.execute "CREATE TABLE t( c #{sql_type} )"
         db.execute "insert into t (c) values ( ? )", ruby_info[:value]
         rows = db.execute "select * from t"
-        rows.first['c'].class.should == ruby_info[:klass]
+        rows.first['c'].class.should eql(ruby_info[:klass])
 
         if [ DateTime, Time ].include?( ruby_info[:klass] ) then
-          rows.first['c'].strftime("%Y-%m-%d %H:%M:%S").should == ruby_info[:value].strftime("%Y-%m-%d %H:%M:%S")
+          rows.first['c'].strftime("%Y-%m-%d %H:%M:%S").should eql(ruby_info[:value].strftime("%Y-%m-%d %H:%M:%S"))
         else
-          rows.first['c'].should == ruby_info[:value]
+          rows.first['c'].should eql(ruby_info[:value])
         end
         db.close
       end
@@ -79,7 +79,7 @@ describe "Integration specifications" do
         db.execute "CREATE TABLE t( c #{sql_type} )"
         db.execute "insert into t (c) values ( ? )", ruby_info[:value]
         rows = db.execute "select * from t"
-        rows.first['c'].should == ruby_info[:result]
+        rows.first['c'].should eql(ruby_info[:result])
         db.close
       end
     end
@@ -102,7 +102,7 @@ describe "Integration specifications" do
         db.execute "CREATE TABLE t( c #{sql_type} )"
         db.execute "insert into t (c) values ( ? )", ruby_info[:value]
         rows = db.execute "select * from t"
-        rows.first['c'].should == ruby_info[:result]
+        rows.first['c'].should eql(ruby_info[:result])
         db.close
       end
     end

data/spec/packer_spec.rb

@@ -21,7 +21,7 @@ describe "Amalgalite::Packer" do
     db = Amalgalite::Database.new( @packer.dbfile )
     db.schema.tables[ @table ].should_not be_nil
     count = db.execute("SELECT count(1) FROM #{@table}").first
-    count.first.should == Amalgalite::Packer.amalgalite_require_order.size
+    count.first.should eql(Amalgalite::Packer.amalgalite_require_order.size)
   end
 
   it "recreates the table if :drop_table option is given " do
@@ -29,13 +29,13 @@ describe "Amalgalite::Packer" do
     db = Amalgalite::Database.new( @packer.dbfile )
     db.schema.tables[ @table ].should_not be_nil
     count = db.execute("SELECT count(1) FROM #{@table}").first
-    count.first.should == Amalgalite::Packer.amalgalite_require_order.size
+    count.first.should eql(Amalgalite::Packer.amalgalite_require_order.size)
 
     np = Amalgalite::Packer.new( :drop_table => true, :table_name => @table  )
-    np.options[ :drop_table ].should == true
+    np.options[ :drop_table ].should eql(true)
     np.check_db( db )
     count = db.execute("SELECT count(1) FROM #{@table}").first
-    count.first.should == 0
+    count.first.should eql(0)
 
   end
 
@@ -46,7 +46,7 @@ describe "Amalgalite::Packer" do
     orig = IO.read( File.join( File.dirname( __FILE__ ), "..", "lib", "amalgalite.rb" ) )
     zipped = db.execute("SELECT contents FROM #{@table} WHERE filename = 'amalgalite'")
     expanded = Amalgalite::Packer.gunzip( zipped.first['contents'].to_s )
-    expanded.should == orig
+    expanded.should eql(orig)
   end
 
   it "has all the lib files in the amalgalite gem" do

data/spec/progress_handler_spec.rb

@@ -80,7 +80,7 @@ describe "Progress Handlers" do
     @iso_db.progress_handler( 5, ph )
     qt = query_thread( @iso_db )
     qt.join
-    ph.call_count.should == 25
+    ph.call_count.should eql(25)
     qt[:exception].should be_instance_of( ::Amalgalite::SQLite3::Error )
     qt[:exception].message.should =~ /interrupted/
   end
@@ -97,7 +97,7 @@ describe "Progress Handlers" do
     @iso_db.remove_progress_handler
     qt = query_thread( @iso_db )
     qt.join
-    ph.call_count.should == 0
+    ph.call_count.should eql(0)
     qt[:exception].should be_nil
   end
 end

data/spec/schema_spec.rb

@@ -21,38 +21,38 @@ describe Amalgalite::Schema do
   it "loads the schema of a database" do
     schema = @iso_db.schema
     schema.load_tables
-    schema.tables.size.should == 2
+    schema.tables.size.should eql(2)
   end
 
   it "lazily loads new table schema" do
-    @iso_db.schema.tables.size.should == 2
+    @iso_db.schema.tables.size.should eql(2)
     sql = "CREATE TABLE t1 ( a, b, c )"
     @iso_db.execute( sql )
-    @iso_db.schema.tables.size.should == 2
+    @iso_db.schema.tables.size.should eql(2)
     @iso_db.schema.dirty!
-    @iso_db.schema.tables['t1'].column_names.should == %w[ a b c ]
-    @iso_db.schema.tables.size.should == 3
+    @iso_db.schema.tables['t1'].column_names.should eql(%w[ a b c ])
+    @iso_db.schema.tables.size.should eql(3)
   end
 
   it "loads the views in the database" do
     sql = "CREATE VIEW v1 AS SELECT c.name, c.two_letter, s.name, s.subdivision FROM country AS c JOIN subcountry AS s ON c.two_letter = s.country"
     @iso_db.execute( sql )
     @iso_db.schema.load_views
-    @iso_db.schema.views.size.should == 1
-    @iso_db.schema.views["v1"].sql.should == sql
+    @iso_db.schema.views.size.should eql(1)
+    @iso_db.schema.views["v1"].sql.should eql(sql)
   end
 
   it "loads the tables and columns" do
     ct = @iso_db.schema.tables['country']
-    ct.name.should == "country"
-    ct.columns.size.should == 3
-    ct.indexes.size.should == 2
-    ct.column_names.should == %w[ name two_letter id ]
-    @iso_db.schema.tables.size.should == 2
+    ct.name.should eql("country")
+    ct.columns.size.should eql(3)
+    ct.indexes.size.should eql(2)
+    ct.column_names.should eql(%w[ name two_letter id ])
+    @iso_db.schema.tables.size.should eql(2)
 
 
     ct.columns['two_letter'].should be_primary_key
-    ct.columns['two_letter'].declared_data_type.should == "TEXT"
+    ct.columns['two_letter'].declared_data_type.should eql("TEXT")
     ct.columns['name'].should_not be_nullable
     ct.columns['name'].should be_not_null_constraint
     ct.columns['name'].should_not be_has_default_value
@@ -61,15 +61,15 @@ describe Amalgalite::Schema do
 
   it "loads the indexes" do
     c = @iso_db.schema.tables['country']
-    c.indexes.size.should == 2
-    c.indexes['country_name'].columns.size.should == 1
+    c.indexes.size.should eql(2)
+    c.indexes['country_name'].columns.size.should eql(1)
     c.indexes['country_name'].should_not be_unique
-    c.indexes['country_name'].sequence_number.should == 0
-    c.indexes['country_name'].columns.first.should == @iso_db.schema.tables['country'].columns['name']
+    c.indexes['country_name'].sequence_number.should eql(0)
+    c.indexes['country_name'].columns.first.should eql(@iso_db.schema.tables['country'].columns['name'])
     c.indexes['sqlite_autoindex_country_1'].should be_unique
 
     subc = @iso_db.schema.tables['subcountry']
-    subc.indexes.size.should == 3
-    subc.indexes['subcountry_country'].columns.first.should == @iso_db.schema.tables['subcountry'].columns['country']
+    subc.indexes.size.should eql(3)
+    subc.indexes['subcountry_country'].columns.first.should eql(@iso_db.schema.tables['subcountry'].columns['country'])
   end
 end

data/spec/sqlite3/database_status_spec.rb

@@ -30,7 +30,7 @@ describe "Amalgalite::SQLite3::Database::Status" do
     stat.reset!
     after = stat.highwater
 
-    after.should == 0
-    after.should_not == before
+    after.should eql(0)
+    after.should_not eql(before)
   end
 end

data/spec/sqlite3/status_spec.rb

@@ -13,6 +13,6 @@ describe "Amalgalite::SQLite3::Status" do
     Amalgalite::SQLite3.status.memory_used.reset!
     Amalgalite::SQLite3.status.memory_used.highwater.should > 0
     after = Amalgalite::SQLite3.status.memory_used.highwater
-    after.should_not == before
+    after.should_not eql(before)
   end
 end

data/spec/sqlite3/version_spec.rb

@@ -5,10 +5,10 @@ describe "Amalgalite::SQLite3::Version" do
   it "should have the sqlite3 version" do
     Amalgalite::SQLite3::VERSION.should =~ /\d\.\d\.\d/
     Amalgalite::SQLite3::Version.to_s.should =~ /\d\.\d\.\d/
-    Amalgalite::SQLite3::Version.to_i.should == 3006010
-    Amalgalite::SQLite3::Version::MAJOR.should == 3
-    Amalgalite::SQLite3::Version::MINOR.should == 6
-    Amalgalite::SQLite3::Version::RELEASE.should == 10
+    Amalgalite::SQLite3::Version.to_i.should eql(3006010)
+    Amalgalite::SQLite3::Version::MAJOR.should eql(3)
+    Amalgalite::SQLite3::Version::MINOR.should eql(6)
+    Amalgalite::SQLite3::Version::RELEASE.should eql(10)
     Amalgalite::SQLite3::Version.to_a.should have(3).items
   end
 end

data/spec/sqlite3_spec.rb

@@ -4,50 +4,50 @@ require 'rbconfig'
 
 describe "Amalgalite::SQLite3" do
   it "is threadsafe is ruby is compiled with pthread support, in this case that is (#{Config::CONFIG['configure_args'].include?( "--enable-pthread" )})" do
-    Amalgalite::SQLite3.threadsafe?.should == Config::CONFIG['configure_args'].include?( "--enable-pthread" )
+    Amalgalite::SQLite3.threadsafe?.should eql(Config::CONFIG['configure_args'].include?( "--enable-pthread" ))
   end
 
   it "knows if an SQL statement is complete" do
-    Amalgalite::SQLite3.complete?("SELECT * FROM sometable;").should == true
-    Amalgalite::SQLite3.complete?("SELECT * FROM sometable;", :utf16 => true).should == true
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable;").should eql(true)
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable;", :utf16 => true).should eql(true)
   end
   
   it "knows if an SQL statement is not complete" do
-    Amalgalite::SQLite3.complete?("SELECT * FROM sometable ").should == false
-    Amalgalite::SQLite3.complete?("SELECT * FROM sometable WHERE ", :utf16 => true).should == false
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable ").should eql(false)
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable WHERE ", :utf16 => true).should eql(false)
   end
 
   it "can produce random data" do
-    Amalgalite::SQLite3.randomness( 42 ).size.should == 42
+    Amalgalite::SQLite3.randomness( 42 ).size.should eql(42)
   end
 
   it "has nil for the default sqlite temporary directory" do
-    Amalgalite::SQLite3.temp_directory.should == nil
+    Amalgalite::SQLite3.temp_directory.should eql(nil)
   end
 
   it "can set the temporary directory" do
-    Amalgalite::SQLite3.temp_directory.should == nil
+    Amalgalite::SQLite3.temp_directory.should eql(nil)
     Amalgalite::SQLite3.temp_directory = "/tmp/testing"
-    Amalgalite::SQLite3.temp_directory.should == "/tmp/testing"
+    Amalgalite::SQLite3.temp_directory.should eql("/tmp/testing")
     Amalgalite::SQLite3.temp_directory = nil
-    Amalgalite::SQLite3.temp_directory.should == nil
+    Amalgalite::SQLite3.temp_directory.should eql(nil)
   end
 
   it "can escape quoted strings" do
-    Amalgalite::SQLite3.escape( "It's a happy day!" ).should == "It''s a happy day!"
+    Amalgalite::SQLite3.escape( "It's a happy day!" ).should eql("It''s a happy day!")
   end
 
   it "can escape a symble into a string" do
-    Amalgalite::SQLite3.escape( :stuff ).should == "stuff"
-    Amalgalite::SQLite3.escape( :"stuff'n" ).should == "stuff''n"
+    Amalgalite::SQLite3.escape( :stuff ).should eql("stuff")
+    Amalgalite::SQLite3.escape( :"stuff'n" ).should eql("stuff''n")
   end
 
   it "can quote and escape single quoted strings" do
-    Amalgalite::SQLite3.quote( "It's a happy day!" ).should == "'It''s a happy day!'"
+    Amalgalite::SQLite3.quote( "It's a happy day!" ).should eql("'It''s a happy day!'")
   end
 
   it "can quote and escape symbols" do
-    Amalgalite::SQLite3.quote( :stuff ).should == "'stuff'"
-    Amalgalite::SQLite3.quote( :"stuff'n" ).should == "'stuff''n'"
+    Amalgalite::SQLite3.quote( :stuff ).should eql("'stuff'")
+    Amalgalite::SQLite3.quote( :"stuff'n" ).should eql("'stuff''n'")
   end
 end

data/spec/statement_spec.rb

@@ -22,16 +22,16 @@ describe Amalgalite::Statement do
 
   it "a statement has a copy of the sql it was prepared with" do
     stmt = @db.prepare( "SELECT strftime('%Y-%m-%d %H:%M:%S', 'now')")
-    stmt.sql.should == "SELECT strftime('%Y-%m-%d %H:%M:%S', 'now')"
+    stmt.sql.should eql("SELECT strftime('%Y-%m-%d %H:%M:%S', 'now')")
     stmt.close
   end
 
   it "steps through results" do
     now = Time.new.utc.strftime("%Y-%m-%d %H:%M")
     @db.prepare( "SELECT strftime('%Y-%m-%d %H:%M', 'now') as now") do |stmt|
-      stmt.should_not == nil
+      stmt.should_not eql(nil)
       stmt.each do |row|
-        row['now'].should == now
+        row['now'].should eql(now)
       end
     end
   end
@@ -39,13 +39,13 @@ describe Amalgalite::Statement do
   it "can prepare a statement without a block" do
     stmt = @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") 
     rs = stmt.execute( ":two" => "JP" )
-    rs.size.should == 1
+    rs.size.should eql(1)
     stmt.close
   end
 
   it "knows how many parameters are in the statement" do
     @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") do |stmt|
-      stmt.check_parameter_count!( 1 ).should == 1
+      stmt.check_parameter_count!( 1 ).should eql(1)
     end
   end
 
@@ -59,8 +59,8 @@ describe Amalgalite::Statement do
   it "can run a query with a named parameter" do
     @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") do |stmt|
       all_rows = stmt.execute( ":two" => "JP" )
-      all_rows.size.should == 1
-      all_rows.first['name'].should == "Japan"
+      all_rows.size.should eql(1)
+      all_rows.first['name'].should eql("Japan")
     end
   end
 
@@ -70,9 +70,9 @@ describe Amalgalite::Statement do
       stmt.execute( "@id" => 891 ) do |row|
         rows << row
       end
-      rows.size.should == 2
-      rows.last['name'].should == "Yugoslavia"
-      rows.first['two_letter'].should == "CS"
+      rows.size.should eql(2)
+      rows.last['name'].should eql("Yugoslavia")
+      rows.first['two_letter'].should eql("CS")
     end
   end
 
@@ -89,17 +89,17 @@ describe Amalgalite::Statement do
     c = 0
     @db.execute("SELECT * from t") do |row|
       c += 1
-      values[ row['x'] ].should == row['y']
+      values[ row['x'] ].should eql(row['y'])
     end
-    c.should == 20
+    c.should eql(20)
   end
 
   it "binds a integer variable correctly" do
     @iso_db.prepare("SELECT * FROM country WHERE id = ? ORDER BY name ") do |stmt|
       all_rows = stmt.execute( 891 )
-      all_rows.size.should == 2
-      all_rows.last['name'].should == "Yugoslavia"
-      all_rows.first['two_letter'].should == "CS"
+      all_rows.size.should eql(2)
+      all_rows.last['name'].should eql("Yugoslavia")
+      all_rows.first['two_letter'].should eql("CS")
     end
   end
 
@@ -128,10 +128,10 @@ describe Amalgalite::Statement do
     db.execute( "create table t1(c1,c2,c3)" )
     db.execute("insert into t1(c1,c2,c3) values (1,2,'abc')")
     rows = db.execute( "select rowid,* from t1")
-    rows.size.should == 1
-    rows.first['rowid'].should == 1
-    rows.first['c1'].should == 1 
-    rows.first['c3'].should == 'abc'
+    rows.size.should eql(1)
+    rows.first['rowid'].should eql(1)
+    rows.first['c1'].should eql(1 )
+    rows.first['c3'].should eql('abc')
   end
 
   it "shows that the rowid column is rowid column" do
@@ -152,9 +152,9 @@ describe Amalgalite::Statement do
   it "has index based access to the result set" do
     @iso_db.prepare("SELECT * FROM country WHERE id = ? ORDER BY name ") do |stmt|
       all_rows = stmt.execute( 891 )
-      all_rows.size.should == 2
-      all_rows.last.first.should == "Yugoslavia"
-      all_rows.first[1].should == "CS"
+      all_rows.size.should eql(2)
+      all_rows.last.first.should eql("Yugoslavia")
+      all_rows.first[1].should eql("CS")
     end
   end
 end

data/spec/tap_spec.rb

@@ -13,7 +13,7 @@ describe Amalgalite::TraceTap do
     s = StringIO.new
     tt = ::Amalgalite::TraceTap.new( s, 'puts' )
     tt.trace('test trace')
-    s.string.should == "test trace\n"
+    s.string.should eql("test trace\n")
   end
   
   it "raises an error if an the wrapped object does not respond to the indicated method"  do
@@ -51,9 +51,9 @@ describe Amalgalite::ProfileSampler do
     s.sample( 84 )
     s.sample( 21 )
     h = s.to_h
-    h['min'].should == 21
-    h['max'].should == 84
-    h['mean'].should == 49
-    h['n'].should == 3
+    h['min'].should eql(21)
+    h['max'].should eql(84)
+    h['mean'].should eql(49.0)
+    h['n'].should eql(3)
   end
 end

data/tasks/config.rb

@@ -38,8 +38,6 @@ Configuration.for('packaging') {
     all       bin + ext + examples + lib + test + data + rdoc + tasks 
   }
 
-  puts "ext files = #{files.ext}"
-
   # ways to package the results
   formats {
     tgz true
@@ -64,7 +62,7 @@ Configuration.for('test') {
   mode      "spec"
   files     Configuration.for("packaging").files.test
   options   %w[ --format progress --color ]
-  ruby_opts %w[ ]
+  ruby_opts %w[ -w ]
 }
 
 #-----------------------------------------------------------------------
@@ -74,7 +72,7 @@ Configuration.for('rcov') {
   output_dir  "coverage"
   libs        %w[ lib ]
   rcov_opts   %w[ --html ]
-  ruby_opts   %w[ ]
+  ruby_opts   %w[ -w ]
   test_files  Configuration.for('packaging').files.test
 }
 #

data/tasks/rspec.rake

@@ -11,13 +11,14 @@ if spec_config = Configuration.for_if_exist?("test") then
       task :default => :spec
 
       require 'spec/rake/spectask'
-      Spec::Rake::SpecTask.new do |r| 
-        r.ruby_opts   = spec_config.ruby_opts
+      rs = Spec::Rake::SpecTask.new do |r| 
+        r.ruby_opts   = spec_config.ruby_opts 
         r.libs        = [ Amalgalite::Paths.lib_path, 
                           Amalgalite::Paths.ext_path,
                           Amalgalite::Paths.root_dir ]
         r.spec_files  = spec_config.files 
         r.spec_opts   = spec_config.options
+        r.warning     = true
 
         if rcov_config = Configuration.for_if_exist?('rcov') then
           r.rcov      = true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: amalgalite
 version: !ruby/object:Gem::Version 
-  version: 0.7.4
+  version: 0.7.5
 platform: ruby
 authors: 
 - Jeremy Hinegardner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-08 00:00:00 -07:00
+date: 2009-02-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency