aquarium 0.1.0

data/spec/aquarium/extensions/hash_spec.rb

@@ -0,0 +1,187 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../spec_example_classes'
+require 'aquarium/extensions/hash'
+require 'aquarium/utils/array_utils'
+require 'aquarium/utils/hash_utils'
+require 'set'
+
+describe Hash, "#intersection" do
+  include Aquarium::Utils::ArrayUtils
+  include Aquarium::Utils::HashUtils
+
+  before(:each) do
+    @hash = {:a => 'a', :b => [:b1, :b2], :c => 'c'}
+  end
+  
+  it "should return the same hash if intersected with itself." do
+    @hash.intersection(@hash).should == @hash
+  end 
+
+  it "should return the same hash if intersected with an equivalent hash." do
+    @hash.intersection({:a => 'a', :b => [:b1, :b2], :c => 'c'}).should == @hash
+  end 
+
+  it "should return an empty hash if one of the input hashes is empty." do
+    {}.intersection(@hash).should == {}
+  end 
+
+  it "should return the common subset hash for two, non-equivalent hashes." do
+    hash2 = {:b =>:b1, :c => 'c', :d => 'd'}
+    @hash.intersection(hash2){|values1, values2| Set.new(make_array(values1)).intersection(Set.new(make_array(values2)))}.should == {:b =>Set.new([:b1]), :c => 'c'}
+  end 
+end
+
+describe "intersection of hashes", :shared => true do
+  include Aquarium::Utils::ArrayUtils
+  include Aquarium::Utils::HashUtils
+
+  before(:each) do
+    @hash = {:a => 'a', :b => [:b1, :b2], :c => 'c'}
+  end
+  
+  it "should return the same hash if intersected with itself." do
+    @hash.intersection(@hash).should == @hash
+  end 
+
+  it "should return the same hash if intersected with an equivalent hash." do
+    @hash.intersection({:a => 'a', :b => [:b1, :b2], :c => 'c'}).should == @hash
+  end 
+
+  it "should return an empty hash if one of the input hashes is empty." do
+    {}.intersection(@hash).should == {}
+  end 
+
+  it "should return the common subset hash for two, non-equivalent hashes." do
+    hash2 = {:b =>:b1, :c => 'c', :d => 'd'}
+    @hash.intersection(hash2){|value1, value2| Set.new(make_array(value1)).intersection(Set.new(make_array(value2)))}.should == {:b =>Set.new([:b1]), :c => 'c'}
+  end 
+end
+
+describe Hash, "#intersection" do
+  it_should_behave_like "intersection of hashes"
+end
+
+describe Hash, "#and" do
+  it_should_behave_like "intersection of hashes"
+end
+
+describe "union of hashes", :shared => true do
+  include Aquarium::Utils::ArrayUtils
+  include Aquarium::Utils::HashUtils
+
+  before(:each) do
+    @hash = {:a => 'a', :b => [:b1, :b2], :c => 'c'}
+  end
+  
+  it "should return the same hash if unioned with itself." do
+    @hash.union(@hash).should == @hash
+  end 
+
+  it "should return the same hash if unioned with an equivalent hash." do
+    @hash.union({:a => 'a', :b => [:b1, :b2], :c => 'c'}).should == @hash
+  end 
+
+  it "should return a hash that is equivalent to the non-empty hash if the other hash is empty." do
+    {}.union(@hash).should == @hash
+    @hash.union({}).should == @hash
+  end 
+
+  it "should return the same hash if unioned with nil." do
+    @hash.union(nil).should == @hash
+  end 
+
+  it "should return a hash equivalent to the output of Hash#merge for two, non-equivalent hashes, with no block given." do
+    hash2 = {:b =>:b3, :c => 'c2', :d => 'd'}
+    @hash.union(hash2).should == {:a => 'a', :b => :b3, :c => 'c2', :d => 'd'}
+  end 
+
+  it "should return the combined hashes for two, non-equivalent hashes, with a block given to merge values into an array." do
+    hash2 = {:b =>:b3, :c => 'c2', :d => 'd'}
+    @hash.union(hash2){|value1, value2| Set.new(make_array(value1)).union(Set.new(make_array(value2)))}.should == {:a => 'a', :b => Set.new([:b1, :b2, :b3]), :c => Set.new(['c', 'c2']), :d => 'd'}
+  end 
+end
+
+describe Hash, "#union" do
+  it_should_behave_like "union of hashes"
+end
+
+describe Hash, "#or" do
+  it_should_behave_like "union of hashes"
+end
+
+describe Hash, "#eql_when_keys_compared?" do
+  include Aquarium::Utils::ArrayUtils
+  include Aquarium::Utils::HashUtils
+
+  it "should return true when comparing a hash to itself." do
+    h1={"1" => :a1, "2" => :a2, "3" => :a3}
+    h1.eql_when_keys_compared?(h1).should == true
+  end
+
+  it "should return true for hashes with string keys that satisfy String#==." do
+    h1={"1" => :a1, "2" => :a2, "3" => :a3}
+    h2={"1" => :a1, "2" => :a2, "3" => :a3}
+    h1.eql_when_keys_compared?(h2).should == true
+  end
+
+  it "should return false for hashes with matching keys, but different values." do
+    h1={"1" => :a1, "2" => :a2, "3" => /a/}
+    h2={"1" => :a1, "2" => :a2, "3" => /b/}
+    h1.eql_when_keys_compared?(h2).should == false
+  end
+
+  it "should return false for hashes where one hash is a subset of the other." do
+    h1={"1" => :a1, "2" => :a2}
+    h2={"1" => :a1, "2" => :a2, "3" => :a3}
+    h1.eql_when_keys_compared?(h2).should == false
+    h2.eql_when_keys_compared?(h1).should == false
+  end
+  
+  it "should return true for hashes with Object keys that define a #<=> method, while Hash#eql? would return false." do
+    class Key
+      def initialize key
+        @key = key
+      end
+      attr_reader :key
+      def eql? other
+        key.eql? other.key
+      end
+      def <=> other
+        key <=> other.key
+      end
+    end
+    
+    h1 = {}; h2 = {}
+    (0...4).each do |index|
+      h1[Key.new(index)] = {index.to_s => [index, index+1]}
+      h2[Key.new(index)] = {index.to_s => [index, index+1]}
+    end
+    h1.eql_when_keys_compared?(h2).should == true
+    h1.eql?(h2).should == false
+  end
+end
+
+describe Hash, "#equivalent_key" do
+  it "should return the key in the hash for which input_value#==(key) is true." do
+    class Key
+      def initialize key
+        @key = key
+      end
+      attr_reader :key
+      def eql? other
+        key.eql? other.key
+      end
+      alias :== :eql?
+    end
+    
+    h1 = {}; h2 = {}
+    (0...4).each do |index|
+      h1[Key.new(index)] = {index.to_s => [index, index+1]}
+      h2[Key.new(index)] = {index.to_s => [index, index+1]}
+    end
+    h1[Key.new(0)].should be_nil
+    h1.equivalent_key(Key.new(0)).should_not be_nil
+    h1.equivalent_key(Key.new(5)).should     be_nil
+  end
+  
+end

data/spec/aquarium/extensions/regex_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'aquarium/extensions/regexp'
+
+describe Regexp, "#empty?" do
+  
+  it "should return true for an empty regular expression" do
+    //.empty?.should be_true
+    Regexp.new("").empty?.should be_true
+  end
+  
+  it "should return true for an empty regular expression with whitespace" do
+    /   /.empty?.should be_true
+    Regexp.new("   ").empty?.should be_true
+  end
+  
+  it "should return false for a non-empty regular expression" do
+    /x/.empty?.should be_false
+    Regexp.new("x").empty?.should be_false
+  end
+end
+
+describe Regexp, "#strip" do
+  it "should return equivalent Regexp if there is no leading or trailing whitespace." do
+    re = /^.{3}.*[a-z]$/
+    re.strip.should == re
+  end
+
+  it "should return new Regexp with removed leading and/or trailing whitespace, when present." do
+    re_string = "^.{3}.*[a-z]$"
+    re = Regexp.new "  #{re_string}  "
+    re.strip.source.should == re_string
+  end
+end
+
+describe Regexp, "#<=>" do
+  it "should sort by the output of #to_s" do
+    ary = [/^x/, /x/, /x$/]
+    ary.sort.should == [/^x/, /x$/, /x/]
+  end
+end

data/spec/aquarium/extensions/set_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../spec_example_classes'
+require 'aquarium/extensions/set'
+
+class Foo
+  def initialize name
+    @name = name
+  end
+  attr_reader :name
+  def eql? other
+    name.eql? other.name
+  end
+  alias :== :eql?
+end
+class Bar
+end
+
+describe "set comparison", :shared => true do
+  it "should return true for the same set" do
+    s = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s.should eql(s)
+  end
+
+  it "should return true for equivalent sets" do
+    s1 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s2 = Set.new [Foo.new("f2"), Foo.new("f1")]
+    s1.should eql(s2)
+  end
+
+  it "should return false for sets where one is a subset of, but not equivalent to, the other set" do
+    s1 = Set.new [Foo.new("f1")]
+    s2 = Set.new [Foo.new("f2"), Foo.new("f1")]
+    s1.should_not eql(s2)
+  end
+
+  it "should return false for sets where some element pairs are of different types" do
+    s1 = Set.new [Foo.new("f1"), Bar.new]
+    s2 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s1.should_not eql(s2)
+  end
+end
+
+describe Set, "#==" do
+  it_should_behave_like "set comparison"
+end
+
+describe Set, "#eql?" do
+  it_should_behave_like "set comparison"
+end
+
+describe Set, "#union_using_eql_comparison" do
+  it "should return an equivalent set if unioned with itself" do
+    s = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s.union_using_eql_comparison(s).should eql(s)
+  end
+
+  it "should return an equivalent set if unioned with another equivalent set" do
+    s1 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s2 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s1.union_using_eql_comparison(s2).should eql(s1)
+  end
+
+  it "should return an equivalent set if unioned with subset" do
+    s1 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s2 = Set.new [Foo.new("f1")]
+    s1.union_using_eql_comparison(s2).should eql(s1)
+    s2.union_using_eql_comparison(s1).should eql(s1)
+  end
+
+  it "should return a combined set if unioned with a disjoint set" do
+    s1 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s2 = Set.new [Foo.new("f3")]
+    s3 = Set.new [Foo.new("f1"), Foo.new("f2"), Foo.new("f3")]
+    s1.union_using_eql_comparison(s2).should eql(s3)
+    s2.union_using_eql_comparison(s1).should eql(s3)
+  end
+end
+
+describe Set, "#intersection_using_eql_comparison" do
+  it "should return an equivalent set if intersectioned with itself" do
+    s = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s.intersection_using_eql_comparison(s).should eql(s)
+  end
+
+  it "should return an equivalent set if intersectioned with another equivalent set" do
+    s1 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s2 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s1.intersection_using_eql_comparison(s2).should eql(s1)
+  end
+
+  it "should return a subset if intersectioned with an equivalent subset" do
+    s1 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s2 = Set.new [Foo.new("f1")]
+    s1.intersection_using_eql_comparison(s2).should eql(s2)
+    s2.intersection_using_eql_comparison(s1).should eql(s2)
+  end
+
+  it "should return an empty set if intersectioned with a disjoint set" do
+    s1 = Set.new [Foo.new("f1"), Foo.new("f2")]
+    s2 = Set.new [Foo.new("f3")]
+    s1.intersection_using_eql_comparison(s2).should eql(Set.new)
+    s2.intersection_using_eql_comparison(s1).should eql(Set.new)
+  end
+end
+

data/spec/aquarium/extensions/string_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'aquarium/extensions/string'
+
+describe  String, "#to_camel_case" do
+  it "should return a camel-case string unchanged" do
+    "CamelCaseString".to_camel_case.should == "CamelCaseString"
+  end
+
+  it "should return a camel-case string from an input string with substrings separated by underscores" do
+    "camel_case_string".to_camel_case.should == "CamelCaseString"
+  end
+
+  it "should return a camel-case string with the first letters of each substring in uppercase and the rest of the letters in each substring unchanged" do
+    "cAmEl_cASE_stRinG".to_camel_case.should == "CAmElCASEStRinG"
+  end
+
+  it "should remove leading and trailing underscores" do
+    "camel_case_string_".to_camel_case.should    == "CamelCaseString"
+    "_camel_case_string".to_camel_case.should    == "CamelCaseString"
+    "camel_case_string__".to_camel_case.should   == "CamelCaseString"
+    "__camel_case_string".to_camel_case.should   == "CamelCaseString"
+    "_camel_case_string_".to_camel_case.should   == "CamelCaseString"
+    "__camel_case_string__".to_camel_case.should == "CamelCaseString"
+  end
+end

data/spec/aquarium/extensions/symbol_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'aquarium/extensions/symbol'
+
+describe "Symbol#empty?" do
+  
+  it "should return true for an empty symbol with whitespace" do
+    :" \t ".empty?.should be_true
+  end
+  
+  it "should return false for a non-empty symbol" do
+    :x.empty?.should be_false
+  end
+end
+
+describe "Symbol#strip" do
+  it "should return equivalent Symbol if there is no leading or trailing whitespace." do
+    :a.strip.should == :a
+  end
+
+  it "should return new Symbol with removed leading and/or trailing whitespace, when present." do
+    :" \ta\t ".strip.should == :a
+  end
+end
+
+describe "Symbol#<=>" do
+  it "should return < 0 if the string representation of the left-hand side symbol is less than the string representation of the right-hand side symbol." do
+    (:a <=> :b).should == -1
+  end
+
+  it "should return > 0 if the string representation of the left-hand side symbol is greater than the string representation of the right-hand side symbol." do
+    (:b <=> :a).should == 1
+  end
+
+  it "should return 0 if the string representation of the left-hand side symbol is equal to the string representation of the right-hand side symbol." do
+    (:a <=> :a).should == 0
+  end
+end

data/spec/aquarium/extras/design_by_contract_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'aquarium/extras/design_by_contract'
+
+describe Aquarium::Extras::DesignByContract, "precondition" do
+  class PreCond
+    def action *args
+    end
+    
+    precondition :method => :action, :message => "Must pass more than one argument." do |jp, *args|
+      args.size > 0
+    end
+  end
+  
+  it "should add advice that raises if the precondition is not satisfied" do
+    lambda {PreCond.new.action}.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
+  end
+  
+  it "should add advice that does not raise if the precondition is satisfied" do
+    PreCond.new.action(:a1)
+  end
+end
+
+describe Aquarium::Extras::DesignByContract, "postcondition" do
+  class PostCond
+    def action *args
+    end
+    
+    postcondition :method => :action, :message => "Must pass more than one argument and first argument must be non-empty." do |jp, *args|
+      args.size > 0 && ! args[0].empty?
+    end
+  end
+  
+  it "should add advice that raises if the postcondition is not satisfied" do
+    lambda {PostCond.new.action}.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
+    lambda {PostCond.new.action("")}.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
+  end
+  
+  it "should add advice that does not raise if the postcondition is satisfied" do
+    PostCond.new.action(:a1)
+  end
+end
+
+
+describe Aquarium::Extras::DesignByContract, "invariant" do
+  class InvarCond
+    def initialize 
+      @invar = 0
+    end
+    attr_reader :invar
+    def good_action
+    end
+    def bad_action
+      @invar = 1
+    end
+    
+    invariant :methods => /action$/, :message => "Must not change the @invar value." do |jp, *args|
+      jp.context.advised_object.invar == 0
+    end
+  end
+  
+  it "should add advice that raises if the invariant is not satisfied" do
+    lambda {InvarCond.new.bad_action}.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
+  end
+  
+  it "should add advice that does not raise if the invariant is satisfied" do
+    InvarCond.new.good_action
+  end
+end