keso 0.1.3

data/lib/values/tuple.rb

@@ -0,0 +1,149 @@
+
+
+class Tuple
+  
+  @hash = nil
+  
+  def initialize *args
+    hash = ImmutableHash.new *args
+    @hash = ImmutableHash.new
+    @heading = Heading.new
+    hash.each do |name_or_attribute,value| 
+      if name_or_attribute.is_a? Attribute
+        
+        if value.is_a? Relation
+          throw "#{value} is not the same as #{name_or_attribute.type}" if value.heading != name_or_attribute.type
+        else
+          throw "#{value} is not the same as #{name_or_attribute.type}" if value.class != name_or_attribute.type
+        end
+        
+        @heading = @heading.add(name_or_attribute)
+        @hash = @hash.add(name_or_attribute,value)
+      else
+        if value.is_a? Relation
+          @heading = @heading.add(Attribute.new(name_or_attribute,value.heading))
+          @hash = @hash.add(Attribute.new(name_or_attribute,value.heading),value)
+        else
+          @heading = @heading.add(Attribute.new(name_or_attribute,value.class))
+          @hash = @hash.add(Attribute.new(name_or_attribute,value.class),value)
+        end
+      end
+    end
+  end
+  
+  def count
+    @hash.count
+  end
+  
+  def heading
+    @heading
+  end
+  
+  def [] attribute_name
+    if attribute_name.is_a? String
+      @hash[self.heading[attribute_name]]
+    elsif attribute_name.is_a? Attribute
+      @hash[attribute_name]
+    elsif attribute_name.is_a? Symbol
+      @hash[self.heading[attribute_name.to_s]]
+    else
+      throw "What should i do with this ? attribute_name=\"#{attribute_name.inspect}\""
+    end
+  end
+  
+  
+  def each &block
+    @hash.each do |key,value|
+      block.call key,value
+    end
+  end
+  
+  def add *values
+    
+    if values.length == 1 and values[0].is_a? Tuple
+      to_return = self
+      values[0].each do |attribute,value|
+        to_return = to_return.add(attribute,value)
+      end
+      
+      to_return
+    else
+      if values[0].is_a? Attribute
+        throw "already exists with this name" unless self.heading[values[0].name].nil?
+      elsif values[0].is_a? String
+        throw "already exists with this name" unless self.heading[values[0]].nil?
+      end
+      Tuple.new(@hash.add(*values))
+    end
+  end
+  
+  def hash
+    @hash.hash
+  end
+  
+  def rename from,to
+    throw "Missing from" if self[from].nil?
+    throw "to already exists" unless self[to].nil?
+    
+    to_return = Tuple.new()
+    to_return._heading = @heading.rename(from,to)
+    to_return._inner_hash = @hash.delete(self.heading[from]).add(Attribute.new(to,self.heading[from].type) ,self[from])
+    
+    to_return
+  end
+  
+  def remove *values
+    
+    to_return = @hash
+    
+    values.each do |attribute_or_name|
+      if attribute_or_name.is_a? Attribute
+        to_return = to_return.delete(attribute_or_name)
+      elsif attribute_or_name.is_a? Hash
+        attribute_or_name.each do |key,value|
+          to_return = to_return.delete(heading[key.to_s])
+        end
+      elsif attribute_or_name.is_a? Array
+        attribute_or_name.each do |name|
+          to_return = to_return.delete(heading[name.to_s])
+        end
+      else
+        to_return = to_return.delete(heading[attribute_or_name.to_s])
+      end
+    end  
+    Tuple.new to_return
+  end
+  
+  def eql? object
+    self == object
+  end
+  
+  def == object
+    if object.equal?(self)
+      true
+    elsif !self.class.equal?(object.class)
+      false
+    else
+      self.inner_hash.eql?(object.inner_hash)
+    end
+  end
+  
+  def method_missing name,&args
+    self[name.to_sym]
+  end
+  
+  protected
+  
+  def inner_hash
+    @hash
+  end
+   
+  def _heading= value
+    @heading = value
+  end
+  
+  def _inner_hash= value
+    @hash = value
+  end
+  
+end

data/spec/attribute_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Attribute do
+
+
+  
+  describe :new do
+    it 'creates a new attrbute with given name and class' do
+      Attribute.new(:name => :age, :type => Fixnum).type.should eql(Fixnum)
+      Attribute.new(:name => :age, :type => Fixnum).name.should eql('age')
+    end
+    
+    it 'creates a new attribute when given a symal as name and a value as type' do
+      Attribute.new(:name => :age, :type => 1).type.should eql(Fixnum)
+      Attribute.new(:name => :age, :type => "ueoau").type.should eql(String)
+    end
+  end
+  
+  describe :== do
+    it 'should return true when to attributes with the same name and type is compared' do
+      (Attribute.new(:name => :age, :type => Fixnum) == Attribute.new(:name => 'age', :type => Fixnum)).should be_true
+    end
+  end
+  
+  describe :eql? do
+    it 'should return true when to attributes with the same name and type is compared' do
+      (Attribute.new(:name => :age, :type => Fixnum).eql?(Attribute.new(:name => 'age', :type => Fixnum))).should be_true
+      
+      person = Relation.new(Tuple.new({:name => 'Bjorn',:age => 29})).add(Tuple.new({:name => 'Emma',:age => 30}))
+      Attribute.new(:name => :persons, :type => person.heading).should eql(Attribute.new(:name => :persons, :type => person.heading))
+    end
+    
+    it 'two diffrent heading types should not be equal' do
+      
+      person = Relation.new(Tuple.new({:name => 'Bjorn',:age => 29})).add(Tuple.new({:name => 'Emma',:age => 30}))
+      person_with_length = Relation.new(Tuple.new({:name => 'Bjorn',:age => 29,:length => 155})).add(Tuple.new({:name => 'Emma',:age => 30, :length => 135}))
+      
+      Attribute.new(:name => :persons, :type => person.heading).should_not eql(Attribute.new(:name => :persons, :type => person_with_length.heading))
+    end
+  end
+  
+  describe :hash do
+    it 'should return the same value for attributes that are equal' do
+      Attribute.new(:name => :age, :type => Fixnum).hash.should eql(Attribute.new(:name => 'age', :type => Fixnum).hash)
+    end
+  end
+  
+  describe :type do
+    it 'is a accesor to the type of the attribute' do
+      Attribute.new(:name => :age, :type => Fixnum).type.should eql(Fixnum)
+    end
+  end
+  
+  describe :name do
+    it 'is a accesor to the type of the attribute' do
+      Attribute.new(:name => :age, :type => Fixnum).name.should eql('age')
+    end
+  end
+  
+end
+

data/spec/heading_spec.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Heading do
+
+  describe :new do
+    it 'creates a new instance of heading with given attribute' do
+      Heading.new(Attribute.new(:name => 'a', :type => 1)).first.type.should eql(Fixnum)
+    end
+    
+    it 'creates a new instance of heading with given name and class' do
+      Heading.new(:name => 'a', :type => Fixnum).first.type.should eql(Fixnum)
+    end
+
+    it 'creates a new instance of heading with given name and value' do
+      Heading.new(:name => 'a', :type => 1).first.type.should eql(Fixnum)
+    end
+    
+    it 'throws an exception if given just a symbol' do
+      lambda{ Heading.new(:bla) }.should raise_error
+    end
+    
+    it 'creates a new empty heading' do
+      Heading.new.first.should be_nil
+    end
+  end
+  
+  describe :eql? do
+    it 'returns true if two headings has the same attributes' do
+      Heading.new(:name => 'a', :type => 1).eql?(Heading.new(:name => 'a', :type => 1)).should be_true
+      Heading.new(:name => 'a', :type => 1).eql?(Heading.new(:name => 'b', :type => 1)).should be_false
+    end
+  end
+  
+  describe :hash do
+    it 'should return an integer related to this hash' do
+      Heading.new(:name => 'a', :type => 1).hash.should eql Heading.new(:name => 'a', :type => 1).hash
+      Heading.new(:name => 'a', :type => 1).hash.should_not eql Heading.new(:name => 'b', :type => 1).hash
+    end
+  end
+  
+  describe :names do
+    it 'should return the names of the attributes in the heading' do
+      Heading.new(Attribute.new(:name => 'a', :type => Fixnum)).add(Attribute.new(:name => 'b', :type => Fixnum)).names.should eql(['a','b'])
+    end
+  end
+  
+  describe :add do
+    it 'accepts attributes or name value pares' do
+      Heading.new.add( Attribute.new(:name => 'a', :type => Fixnum)).first.type.should eql(Fixnum)
+      Heading.new.add(:name => 'a', :type => Fixnum).first.type.should eql(Fixnum)
+    end 
+    
+    it 'should add return a heading with all the attributes of the supplied heading' do
+      Heading.new.add( Attribute.new(:name => 'a', :type => Fixnum)).add(Heading.new(:name => 'b', :type => Fixnum)).should eql(Heading.new(:name => 'a', :type => 1).add(Attribute.new(:name => 'b', :type => Fixnum)))
+    end
+    
+    
+    it 'only accepts attributes or name value pares' do
+      lambda{ Heading.new.add(:test,:test) }.should raise_error
+    end
+    
+    it 'returns a new instance' do
+      h = Heading.new 
+      h.add(:name => 'a', :type => Fixnum).should_not eql(h)
+    end
+    
+    it 'it should accept a heading as a type' do
+      heading_type = Heading.new(:name => 'name', :type => String)
+      
+      Heading.new(:name => 'a', :type => 1).add(:name => 'Names', :type => heading_type)
+      
+    end 
+  end
+  
+  describe :[] do
+    it 'returns the attribute for the given attribute name' do
+      Heading.new.add(:name => 'a', :type => Fixnum)[:a].should eql(Attribute.new(:name => 'a', :type => Fixnum))
+    end
+  end
+  
+  describe :rename do
+    it 'changes the name of a current attribute' do
+      Heading.new.add(:name => 'name', :type => String).rename(:name ,:title).should eql(Heading.new.add(:name => :title,:type => String))
+    end
+    
+    it 'should throw an exception' do
+      lambda { Heading.new.add(:name => :name,:type => String).add(:name => :age,:type => Fixnum).rename(:age ,:name) }.should raise_error(ArgumentError)
+      lambda { Heading.new.add(:name => :age,:type => Fixnum).rename(:year ,:some_other_year) }.should raise_error(ArgumentError)
+    end
+  end
+  
+  
+  describe :remove do
+    it 'removes given attribute' do
+      Heading.new(Attribute.new(:name => 'a', :type => 1)).remove(Attribute.new(:name => 'a', :type => 1)).count.should eql(0)
+    end
+    
+    it 'removes given attribute name' do
+      Heading.new(Attribute.new(:name => 'a', :type => 1)).remove(:a).count.should eql(0)
+    end
+    
+    it 'returns a new instance' do
+      h = Heading.new Attribute.new(:name => 'a', :type => 1)
+      h.remove(Attribute.new(:name => 'a', :type => 1)).should_not eql(h)
+    end
+  end
+  
+  
+  describe :each do
+    it 'iterates over all the attributes in the heading' do
+    
+      
+      count = 0
+      Heading.new.add(Attribute.new(:name => 'a', :type => Fixnum)).add(Heading.new(:name => 'b', :type => Fixnum)).each do |attribute|
+        count += 1
+      end
+  
+      count.should eql(2)
+
+      
+    end
+  end
+  
+  
+end

data/spec/immutable_hash_spec.rb

@@ -0,0 +1,200 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ImmutableHash do
+  
+  describe :new do
+    it 'takes a ruby hash as argument and returns a ImmutableHash with entries from the supplied hash' do
+      ih = ImmutableHash.new({:a => :b})
+      ih.should be_an_instance_of ImmutableHash
+      ih[:a].should eql(:b)
+    end
+    
+    it 'returns a ImmutableHash' do
+      ImmutableHash.new.should be_an_instance_of ImmutableHash
+    end
+  end
+  
+  
+  describe :keys do
+    it 'returns an array of all keys' do
+      ImmutableHash.new({:a => :b}).keys.should eql([:a])
+    end
+  end
+  
+  describe :values do 
+    it 'returns an array of all values' do
+      ImmutableHash.new({:a => :b}).values.should eql([:b])
+    end
+  end
+  
+  describe :size do
+    it 'should return the amount of entries in the hash' do
+      ImmutableHash.new({:a => :b}).size.should eql(1)
+      ImmutableHash.new({:a => :b,:c => :b}).size.should eql(2)
+    end
+  end
+  
+  describe :count do
+    it 'should return the amount of entries in the hash' do
+      ImmutableHash.new({:a => :b}).size.should eql(1)
+      ImmutableHash.new({:a => :b,:c => :b}).size.should eql(2)
+    end
+  end
+  
+  describe :[] do
+    it 'returns nil or the value pointed to by the key' do
+       ImmutableHash.new({:a => :b})[:a].should eql(:b)
+       ImmutableHash.new({:a => :b})[:c].should be_nil
+    end
+  end
+  
+  describe :add do
+    it 'creates a new hash with all the entries plus a new of from the key and value parameters' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.add :c,:d
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+    
+    it 'can take a hash and returns a new imutable instance with all the current entries plus the ones from the hash' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.add({:e => :f,:c => :d})
+      ih2.count.should eql(3)
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+    
+    it 'can take another imutable hash and returns a new instance with the entries of both' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.add ImmutableHash.new({:e => :f,:c => :d})
+      ih2.count.should eql(3)
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+  end
+  
+  describe :set do
+    it 'creates a new hash with all the entries plus a new of from the key and value parameters' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.set :c,:d
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+    
+    it 'can take a hash and returns a new imutable instance with all the current entries plus the ones from the hash' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.set({:e => :f,:c => :d})
+      ih2.count.should eql(3)
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+    
+    it 'can take another imutable hash and returns a new instance with the entries of both' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.set ImmutableHash.new({:e => :f,:c => :d})
+      ih2.count.should eql(3)
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+  end
+  
+  describe :+ do
+    it 'creates a new hash with all the entries plus a new of from the key and value parameters' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.add :c,:d
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+    
+    it 'can take a hash and returns a new imutable instance with all the current entries plus the ones from the hash' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.add({:e => :f,:c => :d})
+      ih2.count.should eql(3)
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+    
+    it 'can take another imutable hash and returns a new instance with the entries of both' do
+      ih1 = ImmutableHash.new({:a => :b})
+      ih2 = ih1.add ImmutableHash.new({:e => :f,:c => :d})
+      ih2.count.should eql(3)
+      ih2.should_not eql(ih1)
+      ih2[:c].should eql(:d)
+      ih1[:c].should be_nil
+    end
+  end
+  
+  describe :delete do
+    it 'returns a new instance of ImmutableHash without the supplied key' do
+      ImmutableHash.new({:a => :b}).delete(:a).count.should eql(0)
+    end
+    
+    it 'returns a new instance of ImmutableHash without the supplied keys' do
+      ImmutableHash.new({:a => :b,:b => :c}).delete([:a,:b]).count.should eql(0)
+    end
+    
+    it 'returns a new instance of ImmutableHash without the entries from the supplied hash' do
+      ImmutableHash.new({:a => :b,:b => :c}).delete({:b => :b,:a => :b}).count.should eql(1)
+    end
+    
+    it 'returns a new instance of ImmutableHash without the entries from the supplied imutable hash' do
+      ImmutableHash.new({:a => :b,:b => :c}).delete(ImmutableHash.new({:b => :b,:a => :b})).count.should eql(1)
+    end
+  end
+   
+  describe :== do
+    it 'retuns true if both instances are equal' do
+      (ImmutableHash.new({:a => :b,:b => :c}) == ImmutableHash.new({:a => :b,:b => :c})).should be_true
+    end
+  end
+  
+  describe :eql? do
+    it 'returns true if the supplied value is eql to this one' do
+      (ImmutableHash.new({:a => :b,:b => :c}).eql?(ImmutableHash.new({:a => :b,:b => :c}))).should be_true
+    end
+  end
+  
+  describe :hash do
+    it 'always returns the same integer for the same value' do
+      ImmutableHash.new({:a => :b,:b => :c}).hash.should eql(ImmutableHash.new({:a => :b,:b => :c}).hash)
+    end
+  end
+  
+  describe :- do
+    it 'returns a new instance of ImmutableHash without the supplied key' do
+      (ImmutableHash.new({:a => :b}) - :a).count.should eql(0)
+    end
+    
+    it 'returns a new instance of ImmutableHash without the supplied keys' do
+      (ImmutableHash.new({:a => :b,:b => :c}) - [:a,:b]).count.should eql(0)
+    end
+    
+    it 'returns a new instance of ImmutableHash without the entries from the supplied hash' do
+      (ImmutableHash.new({:a => :b,:b => :c}) - {:b => :b,:a => :b}).count.should eql(1)
+    end
+    
+    it 'returns a new instance of ImmutableHash without the entries from the supplied imutable hash' do
+      (ImmutableHash.new({:a => :b,:b => :c}) - ImmutableHash.new({:b => :b,:a => :b})).count.should eql(1)
+    end
+  end
+
+  describe :each do
+    it 'takes a code block that and for each key => value it yiels' do
+      hash = {}
+      ImmutableHash.new({:a => :b,:b => :c}).each do |key,value|
+        hash[key] = value;
+      end
+      
+      hash.should eql({:a => :b,:b => :c})
+    end
+  end
+
+end