sequel_core 1.4.0 → 1.5.0

data/lib/sequel_core/model.rb

@@ -1,8 +0,0 @@
-module Sequel
-  class Model
-    def self.database_opened(db)
-      @db ||= db if (self == Model)
-    end
-  end
-end
-

data/spec/array_keys_spec.rb

@@ -1,682 +0,0 @@
-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 work correctly with dataset with transforms" do
-    @ds.first.should == {:a => 1, :b => 2, :c => 3}
-    Sequel.use_array_tuples
-    
-    @ds.transform(:a => [proc {|x| x + 10}, proc {|x| x - 10}])
-    a = @ds.first
-    a.class.should == Array
-    a[:a].should == 11
-    a[:b].should == 2
-    a[:c].should == 3
-    a[:d].should == nil
-
-    a = @ds.all[0]
-    a.class.should == Array
-    a[:a].should == 11
-    a[:b].should == 2
-    a[:c].should == 3
-    a[:d].should == nil
-    
-    b = [12]; b.keys = [:a]
-    @ds.insert_sql(b).should == "INSERT INTO items (a) VALUES (2)"
-  end
-  
-  specify "should work correctly with dataset with model" do
-    ccc = Class.new do
-      attr_reader :values
-      def initialize(v)
-        @values = v
-      end
-    end
-    
-    @ds.first.should == {:a => 1, :b => 2, :c => 3}
-    Sequel.use_array_tuples
-    
-    @ds.set_model(ccc)
-    a = @ds.first
-    a.class.should == ccc
-    a.values.class.should == Array
-    a.values[:a].should == 1
-    a.values[:b].should == 2
-    a.values[:c].should == 3
-    a.values[:d].should == nil
-
-    a = @ds.all[0]
-    a.class.should == ccc
-    a.values.class.should == Array
-    a.values[:a].should == 1
-    a.values[:b].should == 2
-    a.values[:c].should == 3
-    a.values[:d].should == nil
-    
-    @ds.each(:naked => true) do |a|
-      a.class.should == Array
-      a[:a].should == 1
-      a[:b].should == 2
-      a[:c].should == 3
-      a[:d].should == nil
-    end
-  end
-  
-  specify "should work correctly with dataset with model and transform" do
-    ccc = Class.new do
-      attr_reader :values
-      def initialize(v)
-        @values = v
-      end
-    end
-    
-    @ds.first.should == {:a => 1, :b => 2, :c => 3}
-    Sequel.use_array_tuples
-    
-    @ds.transform(:a => [proc {|x| x + 10}, proc {|x| x - 10}])
-    @ds.set_model(ccc)
-    a = @ds.first
-    a.class.should == ccc
-    a.values.class.should == Array
-    a.values[:a].should == 11
-    a.values[:b].should == 2
-    a.values[:c].should == 3
-    a.values[:d].should == nil
-
-    a = @ds.all[0]
-    a.class.should == ccc
-    a.values.class.should == Array
-    a.values[:a].should == 11
-    a.values[:b].should == 2
-    a.values[:c].should == 3
-    a.values[:d].should == nil
-
-    @ds.each(:naked => true) do |a|
-      a.class.should == Array
-      a[:a].should == 11
-      a[:b].should == 2
-      a[:c].should == 3
-      a[:d].should == nil
-    end
-  end
-  
-  specify "should work correctly with denuded dataset" do
-    ccc = Class.new do
-      attr_reader :values
-      def initialize(v)
-        @values = v
-      end
-    end
-    
-    @ds.first.should == {:a => 1, :b => 2, :c => 3}
-    Sequel.use_array_tuples
-    
-    @ds.set_model(ccc)
-    @ds.set_model(nil)
-
-    a = @ds.first
-    a.class.should == Array
-    a[:a].should == 1
-    a[:b].should == 2
-    a[:c].should == 3
-    a[:d].should == nil
-    
-    a = @ds.all[0]
-    a.class.should == Array
-    a[:a].should == 1
-    a[:b].should == 2
-    a[:c].should == 3
-    a[:d].should == nil
-  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
-  
-  specify "should apply and unapply correctly to dataset with array_tuples_fetch_rows" do
-    @c.class_def(:fetch_rows) {'yo hash'}
-    @c.class_def(:array_tuples_fetch_rows) {'yo array'}
-    Sequel.use_array_tuples
-    
-    @ds.fetch_rows.should == 'yo array'
-    
-    Sequel.use_hash_tuples
-    @ds.fetch_rows.should == 'yo hash'
-  end
-end