sequel 0.4.4.1 → 0.4.4.2

data/lib/sequel/migration.rb

@@ -50,10 +50,12 @@ module Sequel
     def self.apply(db, direction)
       obj = new(db)
       case direction
-      when :up: obj.up
-      when :down: obj.down
+      when :up
+        obj.up
+      when :down
+        obj.down
       else
-        raise SequelError, "Invalid migration direction (#{direction})"
+        raise ArgumentError, "Invalid migration direction specified (#{direction.inspect})"
       end
     end
 
@@ -104,8 +106,8 @@ module Sequel
       # determine current and target version and direction
       current ||= get_current_migration_version(db)
       target ||= latest_migration_version(directory)
-      raise SequelError, "No current version available" if current.nil?
-      raise SequelError, "No target version available" if target.nil?
+      raise Error, "No current version available" if current.nil?
+      raise Error, "No target version available" if target.nil?
 
       direction = current < target ? :up : :down
       

data/lib/sequel/model.rb

@@ -256,7 +256,7 @@ module Sequel
     def self.[](*args)
       args = args.first if (args.size == 1)
       if args === true || args === false
-        raise SequelError, "Invalid filter specified. Did you mean to supply a hash?"
+        raise Error::InvalidFilter, "Did you mean to supply a hash?"
       end
       dataset[(Hash === args) ? args : primary_key_hash(args)]
     end

data/lib/sequel/model/base.rb

@@ -3,7 +3,7 @@ module Sequel
     # Returns the database associated with the Model class.
     def self.db
       @db ||= (superclass != Object) && superclass.db or
-      raise SequelError, "No database associated with #{self}"
+      raise Error, "No database associated with #{self}"
     end
     
     # Sets the database associated with the Model class.
@@ -20,7 +20,7 @@ module Sequel
     # Returns the dataset associated with the Model class.
     def self.dataset
       @dataset || super_dataset or
-      raise SequelError, "No dataset associated with #{self}"
+      raise Error, "No dataset associated with #{self}"
     end
     
     def self.super_dataset # :nodoc:
@@ -32,7 +32,7 @@ module Sequel
     # See Dataset#columns for more information.
     def self.columns
       @columns ||= @dataset.columns or
-      raise SequelError, "Could not fetch columns for #{self}"
+      raise Error, "Could not fetch columns for #{self}"
     end
 
     # Sets the dataset associated with the Model class.

data/lib/sequel/model/hooks.rb

@@ -1,9 +1,5 @@
 module Sequel
   class Model
-
-    class ChainBroken < RuntimeError # :nodoc:
-    end
-
     # This Hash translates verbs to methodnames used in chain manipulation
     # methods.
     VERB_TO_METHOD = {:prepend => :unshift, :append => :push}

data/lib/sequel/model/record.rb

@@ -87,7 +87,7 @@ module Sequel
           @pk ||= {key => @values[key]}
         end
         class_def(:cache_key) do
-          pk = @values[key] || (raise SequelError, 'no primary key for this record')
+          pk = @values[key] || (raise Error, 'no primary key for this record')
           @cache_key ||= "#{self.class}:#{pk}"
         end
         meta_def(:primary_key_hash) do |v|
@@ -118,11 +118,11 @@ module Sequel
     
     def self.no_primary_key #:nodoc:
       meta_def(:primary_key) {nil}
-      meta_def(:primary_key_hash) {|v| raise SequelError, "#{self} does not have a primary key"}
-      class_def(:this)      {raise SequelError, "No primary key is associated with this model"}
-      class_def(:pk)        {raise SequelError, "No primary key is associated with this model"}
-      class_def(:pk_hash)   {raise SequelError, "No primary key is associated with this model"}
-      class_def(:cache_key) {raise SequelError, "No primary key is associated with this model"}
+      meta_def(:primary_key_hash) {|v| raise Error, "#{self} does not have a primary key"}
+      class_def(:this)      {raise Error, "No primary key is associated with this model"}
+      class_def(:pk)        {raise Error, "No primary key is associated with this model"}
+      class_def(:pk_hash)   {raise Error, "No primary key is associated with this model"}
+      class_def(:cache_key) {raise Error, "No primary key is associated with this model"}
     end
     
     # Creates new instance with values set to passed-in Hash ensuring that
@@ -149,7 +149,7 @@ module Sequel
     
     # Returns a key unique to the underlying record for caching
     def cache_key
-      pk = @values[:id] || (raise SequelError, 'no primary key for this record')
+      pk = @values[:id] || (raise Error, 'no primary key for this record')
       @cache_key ||= "#{self.class}:#{pk}"
     end
 
@@ -251,7 +251,7 @@ module Sequel
     
     # Reloads values from database and returns self.
     def refresh
-      @values = this.first || raise(SequelError, "Record not found")
+      @values = this.first || raise(Error, "Record not found")
       self
     end
 
@@ -285,7 +285,7 @@ module Sequel
           end
           
           # otherwise, raise an error
-          raise SequelError, "Invalid column (#{att.inspect}) for #{self}"
+          raise Error, "Invalid column (#{att.inspect}) for #{self}"
         end
 
         # define the column accessor

data/lib/sequel/model/relations.rb

@@ -35,7 +35,7 @@ module Sequel
       end
       
       from = opts[:from]
-      from || (raise SequelError, "No association source defined (use :from option)")
+      from || (raise Error, "No association source defined (use :from option)")
       key = opts[:key] || (name.to_s + ID_POSTFIX).to_sym
       
       setter_name = "#{name}=".to_sym
@@ -93,7 +93,7 @@ module Sequel
       
       
       from = opts[:from]
-      from || (raise SequelError, "No association source defined (use :from option)")
+      from || (raise Error, "No association source defined (use :from option)")
       key = opts[:key] || (self.to_s + ID_POSTFIX).to_sym
       
       case from

data/lib/sequel/pretty_table.rb

@@ -41,9 +41,12 @@ module Sequel
     
     def self.format_cell(size, v)
       case v
-      when Bignum, Fixnum: "%#{size}d" % v
-      when Float: "%#{size}g" % v
-      else "%-#{size}s" % v.to_s
+      when Bignum, Fixnum
+        "%#{size}d" % v
+      when Float
+        "%#{size}g" % v
+      else
+        "%-#{size}s" % v.to_s
       end
     end
     

data/lib/sequel/schema/schema_sql.rb

@@ -9,11 +9,16 @@ module Sequel
     
       def on_delete_clause(action)
         case action
-        when :restrict: RESTRICT
-        when :cascade: CASCADE
-        when :set_null: SET_NULL
-        when :set_default: SET_DEFAULT
-        else NO_ACTION
+        when :restrict
+          RESTRICT
+        when :cascade
+          CASCADE
+        when :set_null
+          SET_NULL
+        when :set_default
+          SET_DEFAULT
+        else
+          NO_ACTION
         end
       end
       
@@ -115,7 +120,7 @@ module Sequel
         when :drop_index
           "DROP INDEX #{default_index_name(table, op[:columns])}"
         else
-          raise SequelError, "Unsupported ALTER TABLE operation"
+          raise Error, "Unsupported ALTER TABLE operation"
         end
       end
     end

data/lib/sequel/worker.rb

@@ -1,9 +1,9 @@
-require 'thread'
+require "thread"
 
 module Sequel
+
   class Worker < Thread
-    class WorkerStopError < RuntimeError; end
-  
+      
     attr_reader :queue
     attr_reader :errors
   
@@ -18,7 +18,7 @@ module Sequel
     
     def work
       loop {next_job}
-    rescue WorkerStopError # signals the worker thread to stop
+    rescue Sequel::Error::WorkerStop # signals the worker thread to stop
     ensure
       rollback! if @transaction && !@errors.empty?
     end
@@ -38,7 +38,7 @@ module Sequel
       while busy?
         sleep 0.1
       end
-      self.raise WorkerStopError
+      self.raise Error::WorkerStop
       super
     end
 
@@ -46,7 +46,7 @@ module Sequel
     def next_job
       @cur = @queue.pop
       @cur.call
-    rescue WorkerStopError => e
+    rescue Error::WorkerStop => e
       raise e
     rescue Exception => e
       @errors << e
@@ -54,4 +54,5 @@ module Sequel
       @cur = nil
     end
   end
-end
+
+end

data/spec/adapters/sqlite_spec.rb

@@ -41,7 +41,7 @@ context "An SQLite database" do
     @db.auto_vacuum = :none
     @db.auto_vacuum.should == :none
     
-    proc {@db.auto_vacuum = :invalid}.should raise_error(SequelError)
+    proc {@db.auto_vacuum = :invalid}.should raise_error(Sequel::Error)
   end
 
   specify "should support getting and setting the synchronous pragma" do
@@ -52,7 +52,7 @@ context "An SQLite database" do
     @db.synchronous = :full
     @db.synchronous.should == :full
     
-    proc {@db.synchronous = :invalid}.should raise_error(SequelError)
+    proc {@db.synchronous = :invalid}.should raise_error(Sequel::Error)
   end
   
   specify "should support getting and setting the temp_store pragma" do
@@ -63,7 +63,7 @@ context "An SQLite database" do
     @db.temp_store = :memory
     @db.temp_store.should == :memory
     
-    proc {@db.temp_store = :invalid}.should raise_error(SequelError)
+    proc {@db.temp_store = :invalid}.should raise_error(Sequel::Error)
   end
   
   specify "should be able to execute multiple statements at once" do

data/spec/array_keys_spec.rb

@@ -1,544 +1,544 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "An array with symbol keys" do
-  setup do
-    @a = [1, 2, 3]
-	  @a.keys = [:a, :b, :c]
-  end
-  
-  specify "should provide subscript access" do
-    @a[0].should == 1
-	  @a[0..1].should == [1, 2]
-	
-	  @a[1] = 4
-	  @a.should == [1, 4, 3]
-  end
-  
-  specify "should provide key access using symbols" do
-    @a[:a].should == 1
-    @a[:b].should == 2
-    @a[:B].should == nil
- 
-    @a[:a] = 11
-    @a.should == [11, 2, 3]
-    @a[:a].should == 11
- 
-    @a[:d] = 4
-    @a.should == [11, 2, 3, 4]
-    @a.keys.should == [:a, :b, :c, :d]
-  end
-  
-  specify "should provide key access using strings" do
-    @a['a'].should == 1
-    @a['A'].should be_nil
-    
-    @a['d'] = 4
-    @a.should == [1, 2, 3, 4]
-    @a.keys.should == [:a, :b, :c, :d]
-  end
-
-  specify "should provide #store functionality" do
-    @a.store(:a, 11)
-    @a.should == [11, 2, 3]
-    
-    @a.store(:d, 4)
-    @a.should == [11, 2, 3, 4]
-
-    @a.store('d', 44)
-    @a.should == [11, 2, 3, 44]
-  end
-
-  specify "should provide #to_hash/#to_h functionality" do
-    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
-    @a.to_h.should == {:a => 1, :b => 2, :c => 3}
-  end
-  
-  specify "should provide #columns as alias to #keys" do
-    @a.columns.should == [:a, :b, :c]
-    @a.columns = [:x, :y, :z]
-    
-    @a[:x].should == 1
-  end
-  
-  specify "should provide #slice functionality with keys" do
-    s = @a.slice(0, 2)
-    s.should == [1, 2]
-    s.keys.should == [:a, :b]
-    
-    s = @a.slice(1..2)
-    s.should == [2, 3]
-    s.keys.should == [:b, :c]
-  end
-  
-  specify "should provide #each_pair iterator" do
-    pairs = []
-    @a.each_pair {|k, v| pairs << [k, v]}
-    pairs.should == [[:a, 1], [:b, 2], [:c, 3]]
-  end
-  
-  specify "should provide stock #delete functionality for arrays without keys" do
-    a = [1, 2, 3]
-    a.delete(2)
-    a.should == [1, 3]
-  end
-  
-  specify "should provide key-based #delete functionality" do
-    @a.delete(:b)
-    @a.should == [1, 3]
-    @a.keys.should == [:a, :c]
-    @a[:a].should == 1
-    @a[:c].should == 3
-  end
-  
-  specify "should separate array keys after #delete/#delete_at" do
-    b = @a.dup
-
-    b.delete(:b)
-
-    @a.keys.should == [:a, :b, :c]
-    b.keys.should == [:a, :c]
-    @a.should == [1, 2, 3]
-    b.should == [1, 3]
-    @a[:b].should == 2
-    b[:b].should == nil
-  end
-  
-  specify "should provide #each_key functionality" do
-    keys = []
-    @a.each_key {|k| keys << k}
-    keys.should == [:a, :b, :c]
-  end
-  
-  specify "should provide #each_value functionality" do
-    values = []
-    @a.each_value {|v| values << v}
-    values.should == [1, 2, 3]
-  end
-  
-  specify "should provide stock #include? functionality for arrays without keys" do
-    [1, 2, 3].include?(2).should be_true
-    [1, 2, 3].include?(4).should be_false
-  end
-
-  specify "should provide #has_key?/#member?/#key?/#include? functionality" do
-    @a.has_key?(:a).should be_true
-    @a.has_key?(:b).should be_true
-    @a.has_key?(:c).should be_true
-    @a.has_key?(:B).should be_false
-    @a.has_key?(:d).should be_false
-
-    @a.has_key?('a').should be_true
-    @a.has_key?('b').should be_true
-    @a.has_key?('c').should be_true
-    @a.has_key?('A').should be_false
-    @a.has_key?('d').should be_false
-
-    @a.key?(:a).should be_true
-    @a.key?(:b).should be_true
-    @a.key?(:c).should be_true
-    @a.key?(:B).should be_false
-    @a.key?(:d).should be_false
-
-    @a.key?('a').should be_true
-    @a.key?('b').should be_true
-    @a.key?('c').should be_true
-    @a.key?('A').should be_false
-    @a.key?('d').should be_false
-
-    @a.member?(:a).should be_true
-    @a.member?(:b).should be_true
-    @a.member?(:c).should be_true
-    @a.member?(:B).should be_false
-    @a.member?(:d).should be_false
-
-    @a.member?('a').should be_true
-    @a.member?('b').should be_true
-    @a.member?('c').should be_true
-    @a.member?('A').should be_false
-    @a.member?('d').should be_false
-
-    @a.include?(:a).should be_true
-    @a.include?(:b).should be_true
-    @a.include?(:c).should be_true
-    @a.include?(:B).should be_false
-    @a.include?(:d).should be_false
-
-    @a.include?('a').should be_true
-    @a.include?('b').should be_true
-    @a.include?('c').should be_true
-    @a.include?('A').should be_false
-    @a.include?('d').should be_false
-  end
-  
-  specify "should provide original #include? functionality for arrays without keys" do
-    [1, 2, 3].include?(:a).should be_false
-    [1, 2, 3].include?(1).should be_true
-  end
-  
-  specify "should provide #has_value?/#value? functionality" do
-    @a.has_value?(1).should be_true
-    @a.has_value?(2).should be_true
-    @a.has_value?(3).should be_true
-    @a.has_value?(4).should be_false
-
-    @a.value?(1).should be_true
-    @a.value?(2).should be_true
-    @a.value?(3).should be_true
-    @a.value?(4).should be_false
-  end
-  
-  specify "should provide #fetch functionality" do
-    @a.fetch(:a).should == 1
-    @a.fetch(:b).should == 2
-    @a.fetch(:c).should == 3
-    proc {@a.fetch(:d)}.should raise_error(IndexError)
-    @a.fetch(:d, 4).should == 4
-    @a.fetch(:d, nil).should == nil
-    
-    @a.fetch(:a) {|v| v.to_s}.should == '1'
-    @a.fetch(:d, 4) {|v| v.to_s}.should == '4'
-  end
-  
-  specify "should provide #values functionality" do
-    @a.values.should == [1, 2, 3]
-  end
-  
-  specify "should provide #dup functionality" do
-    b = @a.dup
-    b.should == [1, 2, 3]
-    b.keys.should == @a.keys
-    
-    b[:a].should == 1
-    b[:b].should == 2
-    b[:c].should == 3
-    b[:d].should be_nil
-    
-    @a.keys << :e
-    @a.keys.should == [:a, :b, :c, :e]
-    b.keys.should == @a.keys
-  end
-  
-  specify "should provide #clone functionality" do
-    b = @a.clone
-    b.should == [1, 2, 3]
-    b.keys.should == @a.keys
-
-    b[:a].should == 1
-    b[:b].should == 2
-    b[:c].should == 3
-    b[:d].should be_nil
-
-    @a.keys << :e
-    @a.keys.should == [:a, :b, :c, :e]
-    b.keys.should_not == @a.keys
-  end
-
-  specify "should provide #merge functionality" do
-    @a.merge(@a).to_hash.should == {:a => 1, :b => 2, :c => 3}
-    
-    @a.merge({:b => 22, :d => 4}).to_hash.should == {:a => 1, :b => 22, :c => 3, :d => 4}
-    
-    b = [1, 2, 3]
-    b.keys = [:b, :c, :d]
-    @a.merge(b).to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
-
-    # call with a block. The block returns the old value passed to it
-    @a.merge(b) {|k, o, n| o}.to_hash.should == {:a => 1, :b => 2, :c => 3, :d => 3}
-  end
-  
-  specify "should provide #merge!/#update!/#update functionality" do
-    @a.merge!(@a)
-    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
-    
-    @a.update(:b => 22)
-    @a.to_hash.should == {:a => 1, :b => 22, :c => 3}
-    
-    b = [1, 2, 3]
-    b.keys = [:b, :c, :d]
-    @a.update!(b)
-    @a.to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
-  end
-end
-
-context "An array with string keys" do
-  setup do
-    @a = [1, 2, 3]
-      @a.keys = ['a', 'b', 'c']
-  end
-
-  specify "should provide key access using symbols" do
-    @a[:a].should == 1
-    @a[:b].should == 2
-    @a[:B].should == nil
-
-    @a[:a] = 11
-    @a.should == [11, 2, 3]
-    @a[:a].should == 11
-
-    @a[:d] = 4
-    @a.should == [11, 2, 3, 4]
-    @a.keys.should == ['a', 'b', 'c', :d]
-  end
-
-  specify "should provide key access using strings" do
-    @a['a'].should == 1
-    @a['A'].should be_nil
-
-    @a['d'] = 4
-    @a.should == [1, 2, 3, 4]
-    @a.keys.should == ['a', 'b', 'c', :d]
-  end
-
-  specify "should provide #store functionality" do
-    @a.store(:a, 11)
-    @a.should == [11, 2, 3]
-
-    @a.store(:d, 4)
-    @a.should == [11, 2, 3, 4]
-
-    @a.store('d', 44)
-    @a.should == [11, 2, 3, 44]
-  end
-
-  specify "should provide #to_hash/#to_h functionality" do
-    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
-    @a.to_h.should == {:a => 1, :b => 2, :c => 3}
-  end
-
-  specify "should provide #columns as alias to #keys" do
-    @a.columns.should == ['a', 'b', 'c']
-    @a.columns = [:x, :y, :z]
-
-    @a[:x].should == 1
-  end
-
-  specify "should provide #slice functionality with keys" do
-    s = @a.slice(0, 2)
-    s.should == [1, 2]
-    s.keys.should == ['a', 'b']
-
-    s = @a.slice(1..2)
-    s.should == [2, 3]
-    s.keys.should == ['b', 'c']
-  end
-
-  specify "should provide #each_pair iterator" do
-    pairs = []
-    @a.each_pair {|k, v| pairs << [k, v]}
-    pairs.should == [['a', 1], ['b', 2], ['c', 3]]
-  end
-
-  specify "should provide key-based #delete functionality" do
-    @a.delete(:b)
-    @a.should == [1, 3]
-    @a.keys.should == ['a', 'c']
-    @a[:a].should == 1
-    @a[:c].should == 3
-  end
-
-  specify "should provide #each_key functionality" do
-    keys = []
-    @a.each_key {|k| keys << k}
-    keys.should == ['a', 'b', 'c']
-  end
-
-  specify "should provide #each_value functionality" do
-    values = []
-    @a.each_value {|v| values << v}
-    values.should == [1, 2, 3]
-  end
-
-  specify "should provide #has_key?/#member?/#key?/#include? functionality" do
-    @a.has_key?(:a).should be_true
-    @a.has_key?(:b).should be_true
-    @a.has_key?(:c).should be_true
-    @a.has_key?(:B).should be_false
-    @a.has_key?(:d).should be_false
-
-    @a.has_key?('a').should be_true
-    @a.has_key?('b').should be_true
-    @a.has_key?('c').should be_true
-    @a.has_key?('A').should be_false
-    @a.has_key?('d').should be_false
-
-    @a.key?(:a).should be_true
-    @a.key?(:b).should be_true
-    @a.key?(:c).should be_true
-    @a.key?(:B).should be_false
-    @a.key?(:d).should be_false
-
-    @a.key?('a').should be_true
-    @a.key?('b').should be_true
-    @a.key?('c').should be_true
-    @a.key?('A').should be_false
-    @a.key?('d').should be_false
-
-    @a.member?(:a).should be_true
-    @a.member?(:b).should be_true
-    @a.member?(:c).should be_true
-    @a.member?(:B).should be_false
-    @a.member?(:d).should be_false
-
-    @a.member?('a').should be_true
-    @a.member?('b').should be_true
-    @a.member?('c').should be_true
-    @a.member?('A').should be_false
-    @a.member?('d').should be_false
-
-    @a.include?(:a).should be_true
-    @a.include?(:b).should be_true
-    @a.include?(:c).should be_true
-    @a.include?(:B).should be_false
-    @a.include?(:d).should be_false
-
-    @a.include?('a').should be_true
-    @a.include?('b').should be_true
-    @a.include?('c').should be_true
-    @a.include?('A').should be_false
-    @a.include?('d').should be_false
-  end
-
-  specify "should provide original #include? functionality for arrays without keys" do
-    [1, 2, 3].include?(:a).should be_false
-    [1, 2, 3].include?(1).should be_true
-  end
-
-  specify "should provide #has_value?/#value? functionality" do
-    @a.has_value?(1).should be_true
-    @a.has_value?(2).should be_true
-    @a.has_value?(3).should be_true
-    @a.has_value?(4).should be_false
-
-    @a.value?(1).should be_true
-    @a.value?(2).should be_true
-    @a.value?(3).should be_true
-    @a.value?(4).should be_false
-  end
-
-  specify "should provide #fetch functionality" do
-    @a.fetch(:a).should == 1
-    @a.fetch(:b).should == 2
-    @a.fetch(:c).should == 3
-    proc {@a.fetch(:d)}.should raise_error(IndexError)
-    @a.fetch(:d, 4).should == 4
-    @a.fetch(:d, nil).should == nil
-
-    @a.fetch(:a) {|v| v.to_s}.should == '1'
-    @a.fetch(:d, 4) {|v| v.to_s}.should == '4'
-  end
-
-  specify "should provide #values functionality" do
-    @a.values.should == [1, 2, 3]
-  end
-
-  specify "should provide #dup functionality" do
-    b = @a.dup
-    b.should == [1, 2, 3]
-    b.keys.should == @a.keys
-
-    b[:a].should == 1
-    b[:b].should == 2
-    b[:c].should == 3
-    b[:d].should be_nil
-
-    @a.keys << :e
-    @a.keys.should == ['a', 'b', 'c', :e]
-    b.keys.should == @a.keys
-  end
-
-  specify "should provide #clone functionality" do
-    b = @a.clone
-    b.should == [1, 2, 3]
-    b.keys.should == @a.keys
-
-    b[:a].should == 1
-    b[:b].should == 2
-    b[:c].should == 3
-    b[:d].should be_nil
-
-    @a.keys << :e
-    @a.keys.should == ['a', 'b', 'c', :e]
-    b.keys.should_not == @a.keys
-  end
-
-  specify "should provide #merge functionality" do
-    @a.merge(@a).to_hash.should == {:a => 1, :b => 2, :c => 3}
-
-    @a.merge({:b => 22, :d => 4}).to_hash.should == {:a => 1, :b => 22, :c => 3, :d => 4}
-
-    b = [1, 2, 3]
-    b.keys = [:b, :c, :d]
-    @a.merge(b).to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
-
-    # call with a block. The block returns the old value passed to it
-    @a.merge(b) {|k, o, n| o}.to_hash.should == {:a => 1, :b => 2, :c => 3, :d => 3}
-  end
-
-  specify "should provide #merge!/#update!/#update functionality" do
-    @a.merge!(@a)
-    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
-
-    @a.update(:b => 22)
-    @a.to_hash.should == {:a => 1, :b => 22, :c => 3}
-
-    b = [1, 2, 3]
-    b.keys = [:b, :c, :d]
-    @a.update!(b)
-    @a.to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
-  end
-end
-
-context "Array.from_hash" do
-  specify "should construct an array with keys from a hash" do
-    h = {:x => 1, :y => 2, :z => 3}
-    a = Array.from_hash(h)
-    a.to_hash.should == h
-  end
-end
-
-context "Sequel.use_array_tuples" do
-  setup do
-    @c = Class.new(Sequel::Dataset) do
-      def fetch_rows(sql, &block)
-        block[{:a => 1, :b => 2, :c => 3}]
-      end
-    end
-    
-    @ds = @c.new(nil).from(:items)
-  end
-  
-  teardown do
-    Sequel.use_hash_tuples
-  end
-  
-  specify "should cause the dataset to return array tuples instead of hashes" do
-    @ds.first.should == {:a => 1, :b => 2, :c => 3}
-    Sequel.use_array_tuples
-    a = @ds.first
-    a.class.should == Array
-    a.values.sort.should == [1, 2, 3]
-    a.keys.map {|k| k.to_s}.sort.should == ['a', 'b', 'c']
-    a[:a].should == 1
-    a[:b].should == 2
-    a[:c].should == 3
-    a[:d].should == nil
-    
-    @ds.transform(:a => [proc {|v| v.to_s}, proc {|v| v.to_i}])
-    a = @ds.first
-    a[:a].should == '1'
-    
-    @ds.transform({})
-    a = @ds.first
-    a[:a].should == 1
-
-    @ds.set_model(Hash)
-  end
-  
-  specify "should be reversible using Sequel.use_hash_tuples" do
-    Sequel.use_array_tuples
-    @ds.first.class.should == Array
-    
-    Sequel.use_hash_tuples
-    @ds.first.should == {:a => 1, :b => 2, :c => 3}
-  end
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "An array with symbol keys" do
+  setup do
+    @a = [1, 2, 3]
+	  @a.keys = [:a, :b, :c]
+  end
+  
+  specify "should provide subscript access" do
+    @a[0].should == 1
+	  @a[0..1].should == [1, 2]
+	
+	  @a[1] = 4
+	  @a.should == [1, 4, 3]
+  end
+  
+  specify "should provide key access using symbols" do
+    @a[:a].should == 1
+    @a[:b].should == 2
+    @a[:B].should == nil
+ 
+    @a[:a] = 11
+    @a.should == [11, 2, 3]
+    @a[:a].should == 11
+ 
+    @a[:d] = 4
+    @a.should == [11, 2, 3, 4]
+    @a.keys.should == [:a, :b, :c, :d]
+  end
+  
+  specify "should provide key access using strings" do
+    @a['a'].should == 1
+    @a['A'].should be_nil
+    
+    @a['d'] = 4
+    @a.should == [1, 2, 3, 4]
+    @a.keys.should == [:a, :b, :c, :d]
+  end
+
+  specify "should provide #store functionality" do
+    @a.store(:a, 11)
+    @a.should == [11, 2, 3]
+    
+    @a.store(:d, 4)
+    @a.should == [11, 2, 3, 4]
+
+    @a.store('d', 44)
+    @a.should == [11, 2, 3, 44]
+  end
+
+  specify "should provide #to_hash/#to_h functionality" do
+    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
+    @a.to_h.should == {:a => 1, :b => 2, :c => 3}
+  end
+  
+  specify "should provide #columns as alias to #keys" do
+    @a.columns.should == [:a, :b, :c]
+    @a.columns = [:x, :y, :z]
+    
+    @a[:x].should == 1
+  end
+  
+  specify "should provide #slice functionality with keys" do
+    s = @a.slice(0, 2)
+    s.should == [1, 2]
+    s.keys.should == [:a, :b]
+    
+    s = @a.slice(1..2)
+    s.should == [2, 3]
+    s.keys.should == [:b, :c]
+  end
+  
+  specify "should provide #each_pair iterator" do
+    pairs = []
+    @a.each_pair {|k, v| pairs << [k, v]}
+    pairs.should == [[:a, 1], [:b, 2], [:c, 3]]
+  end
+  
+  specify "should provide stock #delete functionality for arrays without keys" do
+    a = [1, 2, 3]
+    a.delete(2)
+    a.should == [1, 3]
+  end
+  
+  specify "should provide key-based #delete functionality" do
+    @a.delete(:b)
+    @a.should == [1, 3]
+    @a.keys.should == [:a, :c]
+    @a[:a].should == 1
+    @a[:c].should == 3
+  end
+  
+  specify "should separate array keys after #delete/#delete_at" do
+    b = @a.dup
+
+    b.delete(:b)
+
+    @a.keys.should == [:a, :b, :c]
+    b.keys.should == [:a, :c]
+    @a.should == [1, 2, 3]
+    b.should == [1, 3]
+    @a[:b].should == 2
+    b[:b].should == nil
+  end
+  
+  specify "should provide #each_key functionality" do
+    keys = []
+    @a.each_key {|k| keys << k}
+    keys.should == [:a, :b, :c]
+  end
+  
+  specify "should provide #each_value functionality" do
+    values = []
+    @a.each_value {|v| values << v}
+    values.should == [1, 2, 3]
+  end
+  
+  specify "should provide stock #include? functionality for arrays without keys" do
+    [1, 2, 3].include?(2).should be_true
+    [1, 2, 3].include?(4).should be_false
+  end
+
+  specify "should provide #has_key?/#member?/#key?/#include? functionality" do
+    @a.has_key?(:a).should be_true
+    @a.has_key?(:b).should be_true
+    @a.has_key?(:c).should be_true
+    @a.has_key?(:B).should be_false
+    @a.has_key?(:d).should be_false
+
+    @a.has_key?('a').should be_true
+    @a.has_key?('b').should be_true
+    @a.has_key?('c').should be_true
+    @a.has_key?('A').should be_false
+    @a.has_key?('d').should be_false
+
+    @a.key?(:a).should be_true
+    @a.key?(:b).should be_true
+    @a.key?(:c).should be_true
+    @a.key?(:B).should be_false
+    @a.key?(:d).should be_false
+
+    @a.key?('a').should be_true
+    @a.key?('b').should be_true
+    @a.key?('c').should be_true
+    @a.key?('A').should be_false
+    @a.key?('d').should be_false
+
+    @a.member?(:a).should be_true
+    @a.member?(:b).should be_true
+    @a.member?(:c).should be_true
+    @a.member?(:B).should be_false
+    @a.member?(:d).should be_false
+
+    @a.member?('a').should be_true
+    @a.member?('b').should be_true
+    @a.member?('c').should be_true
+    @a.member?('A').should be_false
+    @a.member?('d').should be_false
+
+    @a.include?(:a).should be_true
+    @a.include?(:b).should be_true
+    @a.include?(:c).should be_true
+    @a.include?(:B).should be_false
+    @a.include?(:d).should be_false
+
+    @a.include?('a').should be_true
+    @a.include?('b').should be_true
+    @a.include?('c').should be_true
+    @a.include?('A').should be_false
+    @a.include?('d').should be_false
+  end
+  
+  specify "should provide original #include? functionality for arrays without keys" do
+    [1, 2, 3].include?(:a).should be_false
+    [1, 2, 3].include?(1).should be_true
+  end
+  
+  specify "should provide #has_value?/#value? functionality" do
+    @a.has_value?(1).should be_true
+    @a.has_value?(2).should be_true
+    @a.has_value?(3).should be_true
+    @a.has_value?(4).should be_false
+
+    @a.value?(1).should be_true
+    @a.value?(2).should be_true
+    @a.value?(3).should be_true
+    @a.value?(4).should be_false
+  end
+  
+  specify "should provide #fetch functionality" do
+    @a.fetch(:a).should == 1
+    @a.fetch(:b).should == 2
+    @a.fetch(:c).should == 3
+    proc {@a.fetch(:d)}.should raise_error(IndexError)
+    @a.fetch(:d, 4).should == 4
+    @a.fetch(:d, nil).should == nil
+    
+    @a.fetch(:a) {|v| v.to_s}.should == '1'
+    @a.fetch(:d, 4) {|v| v.to_s}.should == '4'
+  end
+  
+  specify "should provide #values functionality" do
+    @a.values.should == [1, 2, 3]
+  end
+  
+  specify "should provide #dup functionality" do
+    b = @a.dup
+    b.should == [1, 2, 3]
+    b.keys.should == @a.keys
+    
+    b[:a].should == 1
+    b[:b].should == 2
+    b[:c].should == 3
+    b[:d].should be_nil
+    
+    @a.keys << :e
+    @a.keys.should == [:a, :b, :c, :e]
+    b.keys.should == @a.keys
+  end
+  
+  specify "should provide #clone functionality" do
+    b = @a.clone
+    b.should == [1, 2, 3]
+    b.keys.should == @a.keys
+
+    b[:a].should == 1
+    b[:b].should == 2
+    b[:c].should == 3
+    b[:d].should be_nil
+
+    @a.keys << :e
+    @a.keys.should == [:a, :b, :c, :e]
+    b.keys.should_not == @a.keys
+  end
+
+  specify "should provide #merge functionality" do
+    @a.merge(@a).to_hash.should == {:a => 1, :b => 2, :c => 3}
+    
+    @a.merge({:b => 22, :d => 4}).to_hash.should == {:a => 1, :b => 22, :c => 3, :d => 4}
+    
+    b = [1, 2, 3]
+    b.keys = [:b, :c, :d]
+    @a.merge(b).to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
+
+    # call with a block. The block returns the old value passed to it
+    @a.merge(b) {|k, o, n| o}.to_hash.should == {:a => 1, :b => 2, :c => 3, :d => 3}
+  end
+  
+  specify "should provide #merge!/#update!/#update functionality" do
+    @a.merge!(@a)
+    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
+    
+    @a.update(:b => 22)
+    @a.to_hash.should == {:a => 1, :b => 22, :c => 3}
+    
+    b = [1, 2, 3]
+    b.keys = [:b, :c, :d]
+    @a.update!(b)
+    @a.to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
+  end
+end
+
+context "An array with string keys" do
+  setup do
+    @a = [1, 2, 3]
+      @a.keys = ['a', 'b', 'c']
+  end
+
+  specify "should provide key access using symbols" do
+    @a[:a].should == 1
+    @a[:b].should == 2
+    @a[:B].should == nil
+
+    @a[:a] = 11
+    @a.should == [11, 2, 3]
+    @a[:a].should == 11
+
+    @a[:d] = 4
+    @a.should == [11, 2, 3, 4]
+    @a.keys.should == ['a', 'b', 'c', :d]
+  end
+
+  specify "should provide key access using strings" do
+    @a['a'].should == 1
+    @a['A'].should be_nil
+
+    @a['d'] = 4
+    @a.should == [1, 2, 3, 4]
+    @a.keys.should == ['a', 'b', 'c', :d]
+  end
+
+  specify "should provide #store functionality" do
+    @a.store(:a, 11)
+    @a.should == [11, 2, 3]
+
+    @a.store(:d, 4)
+    @a.should == [11, 2, 3, 4]
+
+    @a.store('d', 44)
+    @a.should == [11, 2, 3, 44]
+  end
+
+  specify "should provide #to_hash/#to_h functionality" do
+    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
+    @a.to_h.should == {:a => 1, :b => 2, :c => 3}
+  end
+
+  specify "should provide #columns as alias to #keys" do
+    @a.columns.should == ['a', 'b', 'c']
+    @a.columns = [:x, :y, :z]
+
+    @a[:x].should == 1
+  end
+
+  specify "should provide #slice functionality with keys" do
+    s = @a.slice(0, 2)
+    s.should == [1, 2]
+    s.keys.should == ['a', 'b']
+
+    s = @a.slice(1..2)
+    s.should == [2, 3]
+    s.keys.should == ['b', 'c']
+  end
+
+  specify "should provide #each_pair iterator" do
+    pairs = []
+    @a.each_pair {|k, v| pairs << [k, v]}
+    pairs.should == [['a', 1], ['b', 2], ['c', 3]]
+  end
+
+  specify "should provide key-based #delete functionality" do
+    @a.delete(:b)
+    @a.should == [1, 3]
+    @a.keys.should == ['a', 'c']
+    @a[:a].should == 1
+    @a[:c].should == 3
+  end
+
+  specify "should provide #each_key functionality" do
+    keys = []
+    @a.each_key {|k| keys << k}
+    keys.should == ['a', 'b', 'c']
+  end
+
+  specify "should provide #each_value functionality" do
+    values = []
+    @a.each_value {|v| values << v}
+    values.should == [1, 2, 3]
+  end
+
+  specify "should provide #has_key?/#member?/#key?/#include? functionality" do
+    @a.has_key?(:a).should be_true
+    @a.has_key?(:b).should be_true
+    @a.has_key?(:c).should be_true
+    @a.has_key?(:B).should be_false
+    @a.has_key?(:d).should be_false
+
+    @a.has_key?('a').should be_true
+    @a.has_key?('b').should be_true
+    @a.has_key?('c').should be_true
+    @a.has_key?('A').should be_false
+    @a.has_key?('d').should be_false
+
+    @a.key?(:a).should be_true
+    @a.key?(:b).should be_true
+    @a.key?(:c).should be_true
+    @a.key?(:B).should be_false
+    @a.key?(:d).should be_false
+
+    @a.key?('a').should be_true
+    @a.key?('b').should be_true
+    @a.key?('c').should be_true
+    @a.key?('A').should be_false
+    @a.key?('d').should be_false
+
+    @a.member?(:a).should be_true
+    @a.member?(:b).should be_true
+    @a.member?(:c).should be_true
+    @a.member?(:B).should be_false
+    @a.member?(:d).should be_false
+
+    @a.member?('a').should be_true
+    @a.member?('b').should be_true
+    @a.member?('c').should be_true
+    @a.member?('A').should be_false
+    @a.member?('d').should be_false
+
+    @a.include?(:a).should be_true
+    @a.include?(:b).should be_true
+    @a.include?(:c).should be_true
+    @a.include?(:B).should be_false
+    @a.include?(:d).should be_false
+
+    @a.include?('a').should be_true
+    @a.include?('b').should be_true
+    @a.include?('c').should be_true
+    @a.include?('A').should be_false
+    @a.include?('d').should be_false
+  end
+
+  specify "should provide original #include? functionality for arrays without keys" do
+    [1, 2, 3].include?(:a).should be_false
+    [1, 2, 3].include?(1).should be_true
+  end
+
+  specify "should provide #has_value?/#value? functionality" do
+    @a.has_value?(1).should be_true
+    @a.has_value?(2).should be_true
+    @a.has_value?(3).should be_true
+    @a.has_value?(4).should be_false
+
+    @a.value?(1).should be_true
+    @a.value?(2).should be_true
+    @a.value?(3).should be_true
+    @a.value?(4).should be_false
+  end
+
+  specify "should provide #fetch functionality" do
+    @a.fetch(:a).should == 1
+    @a.fetch(:b).should == 2
+    @a.fetch(:c).should == 3
+    proc {@a.fetch(:d)}.should raise_error(IndexError)
+    @a.fetch(:d, 4).should == 4
+    @a.fetch(:d, nil).should == nil
+
+    @a.fetch(:a) {|v| v.to_s}.should == '1'
+    @a.fetch(:d, 4) {|v| v.to_s}.should == '4'
+  end
+
+  specify "should provide #values functionality" do
+    @a.values.should == [1, 2, 3]
+  end
+
+  specify "should provide #dup functionality" do
+    b = @a.dup
+    b.should == [1, 2, 3]
+    b.keys.should == @a.keys
+
+    b[:a].should == 1
+    b[:b].should == 2
+    b[:c].should == 3
+    b[:d].should be_nil
+
+    @a.keys << :e
+    @a.keys.should == ['a', 'b', 'c', :e]
+    b.keys.should == @a.keys
+  end
+
+  specify "should provide #clone functionality" do
+    b = @a.clone
+    b.should == [1, 2, 3]
+    b.keys.should == @a.keys
+
+    b[:a].should == 1
+    b[:b].should == 2
+    b[:c].should == 3
+    b[:d].should be_nil
+
+    @a.keys << :e
+    @a.keys.should == ['a', 'b', 'c', :e]
+    b.keys.should_not == @a.keys
+  end
+
+  specify "should provide #merge functionality" do
+    @a.merge(@a).to_hash.should == {:a => 1, :b => 2, :c => 3}
+
+    @a.merge({:b => 22, :d => 4}).to_hash.should == {:a => 1, :b => 22, :c => 3, :d => 4}
+
+    b = [1, 2, 3]
+    b.keys = [:b, :c, :d]
+    @a.merge(b).to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
+
+    # call with a block. The block returns the old value passed to it
+    @a.merge(b) {|k, o, n| o}.to_hash.should == {:a => 1, :b => 2, :c => 3, :d => 3}
+  end
+
+  specify "should provide #merge!/#update!/#update functionality" do
+    @a.merge!(@a)
+    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
+
+    @a.update(:b => 22)
+    @a.to_hash.should == {:a => 1, :b => 22, :c => 3}
+
+    b = [1, 2, 3]
+    b.keys = [:b, :c, :d]
+    @a.update!(b)
+    @a.to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
+  end
+end
+
+context "Array.from_hash" do
+  specify "should construct an array with keys from a hash" do
+    h = {:x => 1, :y => 2, :z => 3}
+    a = Array.from_hash(h)
+    a.to_hash.should == h
+  end
+end
+
+context "Sequel.use_array_tuples" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      def fetch_rows(sql, &block)
+        block[{:a => 1, :b => 2, :c => 3}]
+      end
+    end
+    
+    @ds = @c.new(nil).from(:items)
+  end
+  
+  teardown do
+    Sequel.use_hash_tuples
+  end
+  
+  specify "should cause the dataset to return array tuples instead of hashes" do
+    @ds.first.should == {:a => 1, :b => 2, :c => 3}
+    Sequel.use_array_tuples
+    a = @ds.first
+    a.class.should == Array
+    a.values.sort.should == [1, 2, 3]
+    a.keys.map {|k| k.to_s}.sort.should == ['a', 'b', 'c']
+    a[:a].should == 1
+    a[:b].should == 2
+    a[:c].should == 3
+    a[:d].should == nil
+    
+    @ds.transform(:a => [proc {|v| v.to_s}, proc {|v| v.to_i}])
+    a = @ds.first
+    a[:a].should == '1'
+    
+    @ds.transform({})
+    a = @ds.first
+    a[:a].should == 1
+
+    @ds.set_model(Hash)
+  end
+  
+  specify "should be reversible using Sequel.use_hash_tuples" do
+    Sequel.use_array_tuples
+    @ds.first.class.should == Array
+    
+    Sequel.use_hash_tuples
+    @ds.first.should == {:a => 1, :b => 2, :c => 3}
+  end
 end