hash-utils 2.0.2 → 2.1.0

data/spec/modules/io_spec.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "IO" do
+    specify("#io?") do
+        io = File::open("./~test", "w")
+        result = io.io?
+        io.close()
+        result.should be_true
+    end
+    after(:all) do 
+        File.unlink("./~test")
+    end    
+end

data/spec/modules/module_spec.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "Module" do
+    specify("#get_module") do
+        require "zlib"
+        Kernel.get_module("Zlib::Inflate").should eq(Zlib::Inflate)
+    end
+end

data/spec/modules/nil_spec.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "NilClass" do
+    specify("#to_boolean") do
+        nil.to_boolean("xyz").should be_false
+    end
+end

data/spec/modules/numeric_spec.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "Numeric" do
+    specify("#compare") do
+        5.compare(1).should eq(1) 
+        5.compare(5).should eq(0) 
+        5.compare(7).should eq(-1)
+    end
+    specify("#negative?") do
+        5.negative?.should be_false
+        -2.negative?.should be_true
+    end
+    specify("#negative!") do
+        5.negative!.should eq(-5) 
+        -5.negative!.should eq(-5)
+    end
+    specify("#number?") do
+        5.number?.should be_true
+    end
+    specify("#positive?") do
+        5.positive?.should be_true
+        -2.positive?.should be_false
+    end
+    specify("#positive!") do
+        5.positive!.should eq(5) 
+        -5.positive!.should eq(5)
+    end
+end

data/spec/modules/object_spec.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "Object" do
+    specify("#**") do
+        ("ab" ** 5).should eq(["ab", "ab", "ab", "ab", "ab"])
+    end
+    specify("#array?") do
+        "".array?.should be_false
+        [].array?.should be_true
+    end
+    specify("#boolean?") do
+        true.boolean?.should be_true
+        false.boolean?.should be_true 
+        "".boolean?.should be_false
+    end
+    specify("#enumerable?") do
+        [].enumerable?.should be_true 
+        5.enumerable?.should be_false
+    end
+    specify("#false?") do
+        false.false?.should be_true 
+        "string".false?.should be_false
+    end
+    specify("#hash?") do
+        "".hash?.should be_false 
+        {}.hash?.should be_true
+    end
+    specify("#in?") do
+        (5.in? 1..7).should be_true 
+        (9.in? 1..7).should be_false
+    end
+    specify("#instance_of_any?") do
+        "".instance_of_any?([String, Symbol]).should be_true
+        "".instance_of_any?([Integer, Float]).should be_false
+        "".instance_of_any?(String, Symbol).should be_true
+    end
+    specify("#io?") do
+        "".io?.should_not == true
+    end
+    specify("#kind_of_any?") do
+        "".kind_of_any?([String, Symbol]).should be_true
+        "".kind_of_any?([Integer, Float]).should be_false
+        "".kind_of_any?(String, Symbol).should be_true
+    end
+    specify("#number?") do
+        :abcd.number?.should be_false
+        5.number?.should be_true
+    end
+    specify("#proc?") do
+        proc = Proc::new { }
+        :abcd.proc?.should be_false 
+        proc.proc?.should be_true
+    end
+    specify("#string?") do
+        "".string?.should be_true
+        5.string?.should be_false
+    end
+    specify("#symbol?") do
+        :abcd.symbol?.should be_true 
+        5.symbol?.should be_false
+    end
+    specify("#to_b") do
+        nil.to_b.should be_false
+        "ab".to_b.should be_true
+    end
+    specify("#to_symbol") do
+        "ab".to_symbol.should eq(:ab)
+        12.to_symbol.should eq(:"12")
+    end
+    specify("#true?") do
+        true.true?.should be_true
+        "string".true?.should be_false
+    end
+end

data/spec/modules/string_spec.rb

@@ -0,0 +1,245 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "String" do
+    specify("#first") do
+        "abcdefgh".first.should eq("a")
+    end
+    specify("#second") do
+        "abcdefgh".second.should eq("b")
+    end
+    specify("#third") do
+        "abcdefgh".third.should eq("c")
+    end
+    specify("#fourth") do
+        "abcdefgh".fourth.should eq("d")
+    end
+    specify("#fifth") do
+        "abcdefgh".fifth.should eq("e")
+    end
+    specify("#sixth") do
+        "abcdefgh".sixth.should eq("f")
+    end
+    specify("#seventh") do
+        "abcdefgh".seventh.should eq("g")
+    end
+    specify("#eighth") do
+        "abcdefgh".eighth.should eq("h")
+    end
+    specify("#cut!") do
+        foo = "0123456789"
+        foo.cut! 3..5
+        foo.should eq("345")
+    end
+    specify("#first_line") do
+        res = true
+        res &= "a\nb\nc\n".first_line == "a\n"
+        res &= "a".first_line == "a"
+        res.should be_true
+    end
+    specify("#first_lines") do
+        res = true
+        res &= "a\nb".first_lines(2) == ["a\n", "b"]
+        res &= "a\nb\nc\n".first_lines(4) == ["a\n", "b\n", "c\n"]
+        res.should be_true
+    end
+    specify("#interlace") do
+        "abc".interlace("123").should eq("a123b123c")
+    end
+    specify("#interlace!") do
+        foo = "abc"
+        foo.interlace! "123"
+        foo.should eq("a123b123c")
+    end
+    specify("#last") do
+        "abc".last.should eq("c")
+    end
+    specify("#last_line") do
+        res = true
+        res &= "a\nb\nc\n".last_line == ""
+        res &= "a\nb\nc".last_line == "c"
+        res &= "a".last_line == "a"
+        res.should be_true
+    end
+    specify("#last_lines") do
+        res = true
+        res &= "a\nb".last_lines(2) == ["a\n", "b"]
+        res &= "a\nb\nc\n".last_lines(4) == ["a\n", "b\n", "c\n", ""]
+        res.should be_true
+    end
+    specify("#lcfirst") do
+        str = "ABCD"
+        str.lcfirst.should eq("aBCD")
+        str.should eq("ABCD")
+    end
+    specify("#lcfirst!") do
+        str = "ABCD"
+        str.lcfirst!.should eq("aBCD")
+        str.should eq("aBCD")
+    end
+    specify("#map") do
+        "012".map { |ch| (ch.to_i + 1).to_s }.should eq("123")
+        "".map { |ch| (ch.to_i + 1).to_s }.should eq("")
+    end
+    specify("#map!") do
+        t = "012"
+        t.map! { |ch| (ch.to_i + 1).to_s }
+        t.should eq("123")
+        
+        t = ""
+        t.map! { |ch| (ch.to_i + 1).to_s }
+        t.should eq("")
+    end
+    specify("#numeric?") do
+        "123".numeric?.should be_true
+        "123a".numeric?.should be_false
+        "12a3".numeric?.should be_false
+        "a123".numeric?.should be_false
+    end
+    specify("#pop") do
+        res = true
+        str = "abcd"
+        res &= str.pop == "d"
+        res &= str == "abc"
+        str = "abcd"
+        res &= str.pop(2) == "cd"
+        res &= str == "ab"
+        res.should be_true
+    end
+    specify("#pop_line") do
+        res = true
+        str = "a\nb\nc\nd"
+        res &= str.pop_line == "d"
+        res &= str = "a\nb\nc\n"
+        res.should be_true
+    end
+    specify("#pop_lines") do
+        res = true
+        str = "a\nb\nc\nd\n"
+        res &= str.pop_lines(2) == ["d\n", ""]
+        res &= str = "a\nb\nc\n"
+        res.should be_true
+    end
+    specify("#push_line") do
+        res = true
+        str = "a\nb\nc\nd"
+        res &= str.push_line("1") == "a\nb\nc\nd\n1"
+        res &= str == "a\nb\nc\nd\n1"
+        res.should be_true
+    end
+    specify("#push_lines") do
+        res = true
+        str = "a\nb\nc\nd"
+        res &= str.push_lines("1", "2") == "a\nb\nc\nd\n1\n2"
+        res &= str == "a\nb\nc\nd\n1\n2"
+        res.should be_true
+    end
+    specify("#random") do
+        str1 = String::random(30)
+        str2 = String::random(30)
+        (str1 != str2).should be_true
+    end
+    specify("#shift") do
+        res = true
+        str = "abcd"
+        res &= str.shift == "a"
+        res &= str == "bcd"
+        str = "abcd"
+        res &= str.shift(2) == "ab"
+        res &= str == "cd"
+        res.should be_true
+    end
+    specify("#shift_line") do
+        res = true
+        str = "a\nb\nc\nd\n"
+        res &= str.shift_line == "a\n"
+        res &= str = "b\nc\nd\n"
+        res.should be_true
+    end
+    specify("#shift_lines") do
+        res = true
+        str = "a\nb\nc\nd\n"
+        res &= str.shift_lines(2) == ["a\n", "b\n"]
+        res &= str = "c\nd\n"
+        res.should be_true
+    end
+    specify("#string?") do
+        "abcd".string?.should be_true
+    end
+    specify("#strtr") do
+        "aa bb".strtr("aa" => "bb", "bb" => "aa").should eq("bb aa")
+        "aa bb".strtr([["aa", "bb"], ["bb", "aa"]]).should eq("bb aa")
+        "aa bb".strtr(["aa", "bb", "bb", "aa"], :flat).should eq("bb aa")
+        "aa bb".strtr(:aa => "bb", :bb => "aa") { |s| s.to_sym }.should eq("bb aa")
+    end
+    specify("#strtr!") do
+        t = "aa bb"
+        t.strtr!("aa" => "bb", "bb" => "aa")
+        t.should eq("bb aa")
+        
+        t = "aa bb"
+        t.strtr!([["aa", "bb"], ["bb", "aa"]])
+        t.should eq("bb aa")
+        
+        t = "aa bb"
+        t.strtr!(["aa", "bb", "bb", "aa"], :flat)
+        t.should eq("bb aa")
+        
+        t = "aa bb"
+        t.strtr!(:aa => "bb", :bb => "aa") { |s| s.to_sym }
+        t.should eq("bb aa")
+    end
+    specify("#swap_with") do
+        foo = "abc"
+        bar = "123"
+        foo.swap_with(bar)
+        
+        foo.should eq("123") 
+        bar.should eq("abc")
+    end
+    specify("#to_a") do
+        "abc".to_a.should eq(["a", "b", "c"])
+        "abc".to_a('X').should eq(["abc"])
+        "aXbXc".to_a('X').should eq(["a", "b", "c"])
+        "".to_a.should eq([ ])
+        "".to_a('X').should eq([ ])
+    end
+    specify("#to_boolean") do
+        "alfa".to_boolean("alfa").should be_true
+    end
+    specify("#ucfirst") do
+        str = "abcd"
+        str.ucfirst.should eq("Abcd")
+        str.should eq("abcd")
+    end
+    specify("#ucfirst!") do
+        str = "abcd"
+        str.ucfirst!.should eq("Abcd")
+        str.should eq("Abcd")
+    end
+    specify("#unshift") do
+        res = true
+        str = "abcd"
+        res &= str.unshift("123") == "123abcd"
+        res &= str == "123abcd"        
+        res.should be_true
+    end
+    specify("#unshift_line") do
+        res = true
+        str = "a\nb\nc\nd\n"
+        res &= str.unshift_line("1") == "1\na\nb\nc\nd\n"
+        res &= str == "1\na\nb\nc\nd\n"
+        res.should be_true
+    end
+    specify("#unshift_lines") do
+        res = true
+        str = "a\nb\nc\nd\n"
+        res &= str.unshift_lines("1", "2") == "1\n2\na\nb\nc\nd\n"
+        res &= str == "1\n2\na\nb\nc\nd\n"
+        res.should be_true
+    end
+
+end

data/spec/modules/stringio_spec.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "StringIO" do
+    specify("#io?") do
+        StringIO::new.io?.should be_true
+    end
+end

data/spec/modules/symbol_spec.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "Symbol" do
+    specify("#<=>") do
+        (:aa <=> :aa).should eq(0)
+        (:aa <=> :bb).should eq(-1)
+        (:bb <=> :aa).should eq(1)
+    end
+    specify("#*") do
+        (:a * 5).should eq(:aaaaa)
+    end
+    specify("#+") do
+        (:a + :b).should eq(:ab)
+    end
+    specify("#[]") do
+        :abcde[0...3].should eq("abc")
+    end
+    specify("#append") do
+        :abcd.append("efg").should eq(:abcdefg)
+    end
+    specify("#end_with?") do
+        :abcde.end_with?("ghi", "cde").should be_true
+    end
+    specify("#prepend") do
+        :abcd.prepend("012").should eq(:"012abcd")
+    end
+    specify("#split") do
+        :ab_cd_ef.split("_", 2).should eq([:ab, :cd_ef])
+    end
+    specify("#start_with?") do
+        :abcde.start_with?("ghi", "abc").should be_true
+    end
+    specify("#strip") do
+        :"  a  ".strip.should eq(:a)
+    end
+end