sequel_core 1.0

data/spec/array_keys_spec.rb

@@ -0,0 +1,679 @@
+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
+  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