hash-utils 2.0.2 → 2.1.0

data/lib/hash-utils/hash.rb

@@ -31,18 +31,44 @@ class Hash
     ##
     # Creates hash by setting default settings in one call.
     #
-    # @param [Hash] values  initial values
     # @param [Object] default  default value
+    # @param [Hash] hash  initial values
     # @param [Proc] block  default block
     # @return [Hash] new hash
     # @since 0.3.0
     #
     
     if not self.respond_to? :create 
-        def self.create(default = nil, hash = { }, &block)
-            hash.default = default
-            hash.default_proc = block if not block.nil?
-            return hash        
+        if Ruby::Version >= "1.9"
+            def self.create(default = nil, hash = nil, &block)
+                if not hash.nil?
+                    hash = hash.dup
+                else
+                    hash = { }
+                end
+                
+                hash.default = default
+                hash.default_proc = block if not block.nil?
+                return hash        
+            end
+        else
+            def self.create(default = nil, hash = nil, &block)
+                if not hash.nil?
+                    hash = hash.dup
+                else
+                    hash = { }
+                end
+                
+                if not block.nil?
+                    new = Hash::new(&block)
+                    new.update(hash) if not hash.empty?
+                    hash = new
+                else
+                    hash.default = default
+                end
+                
+                return hash      
+            end
         end
     end
 
@@ -357,9 +383,11 @@ class Hash
 
     if not self.__hash_utils_instance_respond_to? :some?    
         def some?(&block)
-            self.one? do |pair|
-                block.call(pair[1])
+            self.each_value do |v|
+                return true if block.call(v)
             end
+            
+            return false
         end
     end
        
@@ -373,7 +401,13 @@ class Hash
     #
     
     if not self.__hash_utils_instance_respond_to? :some_pairs?
-        alias :some_pairs? :one?
+        def some_pairs?(&block)
+            self.each_pair do |pair|
+                return true if block.call(pair)
+            end
+            
+            return false
+        end
     end
     
     ##
@@ -383,7 +417,7 @@ class Hash
     # @since 0.4.0
     #
     
-    if not self.__hash_utils_instance_respond_to? :to_h
+    if (not self.__hash_utils_instance_respond_to? :to_h) or (Ruby::Version >= "2.0")
         def to_h(mode = nil)
             self
         end

data/lib/hash-utils/object.rb

@@ -321,12 +321,16 @@ class Object
     #
     # @return [Symbol] symbol representation of the object
     # @since 1.1.0
+    # @since 2.1.0 is +#to_sym+ deprecated in favor to +#to_symbol+
     #
     
-    if not __hash_utils_object_respond_to? :to_sym
-        def to_sym
+    if not __hash_utils_object_respond_to? :to_symbol
+        def to_symbol
             self.to_s.to_sym
         end
     end
 
+    if not __hash_utils_object_respond_to? :to_sym
+        alias :to_sym :to_symbol
+    end
 end

data/lib/hash-utils/string.rb

@@ -215,13 +215,24 @@ class String
     #
     
     if not self.__hash_utils_instance_respond_to? :map
-        def map(&block)
-            buffer = " " * self.length
-            self.length.times do |i|
-                buffer[i] = block.call(self[i])
+        if Ruby::Version >= "1.9"
+            def map(&block)
+                buffer = " " * self.length
+                self.length.times do |i|
+                    buffer[i] = block.call(self[i]).to_s
+                end
+                        
+                return buffer
+            end
+        else
+            def map(&block)
+                buffer = " " * self.length
+                self.length.times do |i|
+                    buffer[i] = block.call(self[i]).to_i
+                end
+                        
+                return buffer
             end
-                    
-            return buffer
         end
     end
     
@@ -235,12 +246,22 @@ class String
     #
     
     if not self.__hash_utils_instance_respond_to? :map!
-        def map!(&block)
-            self.length.times do |i|
-                self[i] = block.call(self[i])
+        if Ruby::Version >= "1.9"
+            def map!(&block)
+                self.length.times do |i|
+                    self[i] = block.call(self[i]).to_s
+                end
+                
+                return self
+            end
+        else
+            def map!(&block)
+                self.length.times do |i|
+                    self[i] = block.call(self[i]).to_i
+                end
+                
+                return self
             end
-            
-            return self
         end
     end
     

data/lib/hash-utils/symbol.rb

@@ -147,5 +147,20 @@ class Symbol
             self.to_s.strip!.to_sym
         end
     end
+    
+    ##
+    # Compares symbols by three-value comparing. Implements the +<=>+
+    # operator in fact.
+    #
+    # @param [Symbol] symbol to compare
+    # @return [Integer]
+    # @since 2.1.0
+    #
+    
+    if not self.__hash_utils_instance_respond_to? :<=>
+        def <=>(symbol)
+            self.to_s <=> symbol.to_s
+        end
+    end
         
 end

data/spec/modules/array_spec.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "Array" do
+    specify("#second") do
+        [1, 2, 3, 4, 5, 6, 7, 8].second.should eq(2)
+    end
+    specify("#third") do
+        [1, 2, 3, 4, 5, 6, 7, 8].third.should eq(3)
+    end
+    specify("#fourth") do
+        [1, 2, 3, 4, 5, 6, 7, 8].fourth.should eq(4)
+    end
+    specify("#fifth") do
+        [1, 2, 3, 4, 5, 6, 7, 8].fifth.should eq(5) 
+    end
+    specify("#sixth") do
+        [1, 2, 3, 4, 5, 6, 7, 8].sixth.should eq(6)
+    end
+    specify("#seventh") do
+        [1, 2, 3, 4, 5, 6, 7, 8].seventh.should eq(7)
+    end
+    specify("#eighth") do
+        [1, 2, 3, 4, 5, 6, 7, 8].eighth.should eq(8)
+    end
+    specify("#array?") do
+        [1, 2, 3].array?.should be_true
+    end
+    specify("#avg") do
+        [1, 2, 3].avg.should eq(2)
+    end
+    specify("#clean") do
+        t = [1, nil]
+        t = t.clean(1)
+        t.should eq([nil])
+    end
+    specify("#clean!") do
+        t = [1, nil]
+        t.clean!(1)
+        t.should eq([nil])
+    end
+    specify("#complete_to") do
+        [1, 2, 3].complete_to(5, :a).should eq([1, 2, 3, :a, :a])
+        [1, 2, 3, 4, 5].complete_to(3).should eq([1, 2, 3])
+    end
+    specify("#complete_to!") do
+        t = [1, 2, 3]
+        t.complete_to! 5, :a
+        t.should eq([1, 2, 3, :a, :a])
+        
+        t = [1, 2, 3, 4, 5]
+        t.complete_to! 3
+        t.should eq([1, 2, 3 ])
+    end
+    specify("#cut") do
+        [1, 2, 3, 4].cut(2).should eq([1, 2])
+        [1, 2, 3, 4].cut(4).should eq([])
+        [1, 2, 3, 4].cut(6).should eq([])
+    end
+    specify("#cut!") do
+        t = [1, 2, 3, 4]
+        t.cut! 2
+        t.should eq([1, 2])
+        
+        t = [1, 2, 3, 4]
+        t.cut! 4
+        t.should eq([])
+        
+        t = [1, 2, 3, 4]
+        t.cut! 6
+        t.should eq([])
+    end
+    specify("#drop!") do
+        t = [1, 2, 3, 4, 5]
+        t.drop! 2
+        t.should eq([3, 4, 5])
+
+        t = [1, 2, 3, 4, 5]
+        t.drop! 0
+        t.should eq([1, 2, 3, 4, 5])
+        
+        t = [1, 2, 3, 4, 5]
+        expect { t.drop! -2 }.to raise_error(ArgumentError, 'attempt to drop negative size')
+    end
+    specify("#expand_by") do
+        [1, 2, 3].expand_by(:a, :b).should eq([1, :a, :b, 2, :a, :b, 3, :a, :b])
+        [1, 2, 3].expand_by([:a, :b]).should eq([1, [:a, :b], 2, [:a, :b], 3, [:a, :b]])
+        [].expand_by([:a, :b]).should eq([ ])
+    end
+    specify("#expand_by!") do
+        t = [1, 2, 3]
+        t.expand_by! :a, :b
+        t.should eq([1, :a, :b, 2, :a, :b, 3, :a, :b])
+        
+        t = [1, 2, 3]
+        t.expand_by! [:a, :b]
+        t.should eq([1, [:a, :b], 2, [:a, :b], 3, [:a, :b]])
+        
+        t = []
+        t.expand_by! [:a, :b]
+        t.should eq([ ])
+    end
+    specify("#interlace") do
+        [1, 2, 3].interlace(:a, :b).should eq([1, :a, :b, 2, :a, :b, 3])
+    end
+    specify("#interlace!") do
+        t = [1, 2, 3]
+        t.interlace! :a, :b
+        t.should eq([1, :a, :b, 2, :a, :b, 3])
+    end
+    specify("#merge!") do
+        t = [1, 2, 3]
+        t.merge!([:a, :b])
+        t.should eq([1, 2, 3, :a, :b])
+    end
+    specify("#remove!") do
+        t = [1, 2, 3, 4]
+        t.remove! { |i| i >= 3 }
+        t.should eq([1, 2])
+
+        t = [1, 2, 3, 4]
+        t.remove! { false }
+        t.should eq([1, 2, 3, 4])
+
+        t = [1, 2, 3, 4]
+        t.remove! { true }
+        t.should eq([ ])        
+    end
+    specify("#shrink_to") do
+        [1, 2, 3, 4, 5].shrink_to(3).should eq([1, 2, 3])
+        [1, 2, 3, 4, 5].shrink_to(6).should eq([1, 2, 3, 4, 5])
+        [1, 2, 3, 4, 5].shrink_to(0).should eq([])
+        expect { [1, 2, 3, 4, 5].shrink_to(-3) }.to raise_error(ArgumentError, "negative argument")
+    end
+    specify("#shrink_to!") do
+        t = [1, 2, 3, 4, 5]
+        t.shrink_to! 3
+        t.should eq([1, 2, 3])
+        
+        t = [1, 2, 3, 4, 5]
+        t.shrink_to! 6
+        t.should eq([1, 2, 3, 4, 5])
+        
+        t = [1, 2, 3, 4, 5]
+        expect { t.shrink_to! -3 }.to raise_error(ArgumentError, "negative argument")
+        
+        t = [1, 2, 3, 4, 5]
+        t.shrink_to! 0
+        t.should eq([])
+    end
+    specify("#sum") do
+        [1, 2, 3].sum.should eq(6)
+    end
+    specify("#to_h") do
+        [[:a, :b], [:b, :a]].to_h.should eq({:a => :b, :b => :a})
+        [:a, :b, :b, :a].to_h(:flat).should eq({:a => :b, :b => :a})
+    end
+    specify("#to_set") do
+        [1, 2, 3].to_set.should eq(Set::new([1, 2, 3]))
+    end
+    specify("#zip!") do
+        t = [1, 2, 3]
+        t.zip!
+        t.should eq([1, 2, 3].zip)
+        
+        t = [1, 2, 3]
+        t.zip!([:a, :b], [:c], [:d, :e, :f])
+        t.should eq([1, 2, 3].zip([:a, :b], [:c], [:d, :e, :f]))
+        
+        t = [1, 2, 3]
+        t.zip!([:a, :b], [:d, :e, :f], [:c])
+        t.should eq([1, 2, 3].zip([:a, :b], [:d, :e, :f], [:c]))
+    end
+end

data/spec/modules/false_spec.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "FalseClass" do
+    specify("#boolean?") do
+        false.boolean?.should be_true
+    end
+    specify("#convert") do
+        false.convert(:a, :b).should eq(:b)
+    end
+    specify("#false?") do
+        false.false?.should be_true
+    end
+    specify("#to_i") do
+        false.to_i.should eq(0)
+    end
+    specify("#true?") do
+        (not false.true?).should be_true
+    end
+end

data/spec/modules/file_spec.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "File" do
+    specify("#touch") do 
+        File.touch("./~test1")
+        File.exists?("./~test1").should be_true
+    end
+    specify("#write") do
+        File.write("./~test2", "some string")
+        File.read("./~test2").should eq("some string")
+    end
+    
+    after(:all) do 
+        File.unlink("./~test1")
+        File.unlink("./~test2")
+    end
+end
+

data/spec/modules/hash_spec.rb

@@ -0,0 +1,223 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011-2012 Martin Kozák (martinkozak@martinkozak.net)
+
+require "spec_helper"
+
+describe "Hash" do
+    specify("#all_pairs?") do
+        t = { :a => 1, :b => 2, :c => 3, :d => 4 }
+        t.all_pairs? { |k, v| k.in? [:a, :b] or v > 2 }.should be_true
+        t.all_pairs? { |k, v| v > 2 }.should be_false
+        { }.all_pairs?.should be_true
+    end
+    specify("#asort") do
+        h = { 3 => :c, 1 => :a,  2 => :b }
+        h.asort.should eq({ 1 => :a, 2 => :b, 3 => :c })        
+    end
+    specify("#asort!") do
+        h = { 3 => :c, 1 => :a,  2 => :b }
+        h.asort!
+        h.should eq({ 1 => :a, 2 => :b, 3 => :c })        
+    end
+    specify("#avg") do
+        { :a => 1, :b => 2 }.avg.should eq(1.5)
+    end 
+    specify("#clean") do
+        t = { :a => 1, :b => nil }
+        t = t.clean(1)
+        t.should eq({ :b => nil })
+    end
+    specify("#clean!") do
+        t = { :a => 1, :b => nil }
+        t.clean!(1)
+        t.should eq({ :b => nil })
+    end
+    specify("::combine") do
+        keys = [:a, :b, :c]
+        values = [1, 2, 3]
+        
+        Hash::combine(keys, values).should eq({ :a => 1, :b => 2, :c => 3 })
+        Hash::combine([ ], [ ]).should eq({ })
+        Hash::combine([:a, :b], [ ]).should eq({ :a => nil, :b => nil })
+        Hash::combine([ ], [1, 2]).should eq({ })
+    end
+    specify("#compact") do
+        t = { :a => 1, :b => nil }
+        t = t.compact
+        t.should eq({ :a => 1 })
+    end
+    specify("#compact!") do
+        t = { :a => 1, :b => nil }
+        t.compact!
+        t.should eq({ :a => 1 })
+    end
+    specify("::create") do
+        proc = Proc::new { |dict, key| dict[key] = "" }
+        t1 = Hash::create(:default)
+        t2 = Hash::define(&proc)
+        
+        t1.default.should eq(:default)
+        t2.default_proc.should eq(proc)
+    end
+    specify("::define") do
+        proc = Proc::new { |dict, key| dict[key] = "" }
+        t1 = Hash::define({:a => :b}, :default)
+        t2 = Hash::define({:a => :b}, &proc)
+        
+        t1.should eq(:a => :b)
+        t1.default.should eq(:default)
+        t2.default_proc.should eq(proc)
+    end
+    specify("#flip") do
+        t = { :a => 1, :b => 2, :c => 2 }
+        result = t.flip
+        (result == { 1 => :a, 2 => :c } or result == { 1 => :a, 2 => :b }).should be_true
+    end
+    specify("#flip!") do
+        t = { :a => 1, :b => 2, :c => 2 }
+        t.flip!
+        (t == { 1 => :a, 2 => :c } or t == { 1 => :a, 2 => :b }).should be_true
+    end
+    specify("#get_pairs") do
+        h = { :a => 1, :b => 2, :c => 3 }
+        result = [ ]
+        h.get_pairs(:a, :c, :d) { |i| result << i }
+        result.should eq([[:a, 1], [:c, 3]])
+    end
+    specify("#get_items") do
+        h = { :a => 1, :b => 2, :c => 3 }
+        h.get_items(:a, :c, :d).should eq({ :a => 1, :c => 3 })
+    end
+    specify("#get_values") do
+        h = { :a => 1, :b => 2, :c => 3 }
+        h.get_values(:a, :c, :d).should eq([1, 3])
+    end
+    specify("#get_values") do
+        { :a => 1, :b => 2, :c => 3 }.hash?.should be_true
+    end
+    specify("#has_all?") do
+        { :a => 1, :b => 2, :c => 3 }.has_all?([:b, :c]).should be_true
+        { :a => 1, :b => 2, :c => 3 }.has_all?([:b, :d]).should be_false
+    end
+    specify("#has_some?") do
+        { :a => 1, :b => 2, :c => 3 }.has_some?([:b, :c]).should be_true
+        { :a => 1, :b => 2, :c => 3 }.has_some?([:b, :d]).should be_true
+        { :a => 1, :b => 2, :c => 3 }.has_some?([:d, :e]).should be_false
+    end
+    specify("#map_values") do
+        { :a => 1, :b => 2 }.map_values { |i| i + 1 }.should eq({ :a => 2, :b => 3 })
+    end
+    specify("#map_values!") do
+        t = { :a => 1, :b => 2 }
+        t.map_values! { |i| i + 1 } 
+        t.should eq({ :a => 2, :b => 3 })
+    end
+    specify("#deep_merge") do
+        h1 = {:a => {:b => :c, :d => :e}}
+        h2 = {:a => {:d => :f, :h => :i}}
+        h = h1.deep_merge(h2) 
+        h.should eq({:a => {:b => :c, :d => :f, :h => :i}})
+        h1.should eq({:a => {:b => :c, :d => :e}})
+    end
+    specify("#deep_merge!") do
+        h = {:a => {:b => :c, :d => :e}}
+        h.deep_merge!({:a => {:d => :f, :h => :i}})
+        h.should eq({:a => {:b => :c, :d => :f, :h => :i}})
+    end
+    specify("#keys_to_sym") do
+        h = {"a" => "b", 2 => "c", "d" => "e"}
+        h.keys_to_sym.should eq({:a => "b", 2 => "c", :d => "e"})
+    end
+    specify("#keys_to_sym!") do
+        h = {"a" => "b", 2 => "c", "d" => "e"}
+        h.keys_to_sym! 
+        h.should eq({:a => "b", 2 => "c", :d => "e"})
+    end
+    specify("#ksort") do
+        h = { 3 => :b, 1 => :a,  2 => :c }
+        h.ksort.should eq({ 1 => :a, 2 => :c, 3 => :b })        
+    end
+    specify("#ksort!") do
+        h = { 3 => :b, 1 => :a,  2 => :c }
+        h.ksort!
+        h.should eq({ 1 => :a, 2 => :c, 3 => :b })        
+    end
+    specify("#map_keys!") do
+        h = {"a" => 1, "b" => 2}
+        h.map_keys! do |k|
+            k.to_sym
+        end
+        
+        h.should eq({:a => 1, :b => 2})
+    end
+    specify("#recreate!") do
+        h = Hash::create(:default, {:a => 1, :b => 2})
+        h.recreate!
+        h.should eq({ })
+        h.default.should eq(:default)
+        
+        proc = Proc::new {  }
+        h = Hash::create(nil, {:a => 1, :b => 2}, &proc)
+        h.recreate!
+        h.default_proc.should eq(proc)
+    end
+    specify("#remove!") do
+        h = {:a => 1, :b => 2, :c => 3, :d => 4}
+        h.remove! { |k, v| k == :c or v > 2 }.should eq({:c => 3, :d => 4})
+        h.should eq({:a => 1, :b => 2})
+    end
+    specify("#reverse") do
+        h = {:a => 1, :b => 2, :c => 3}
+        h.reverse.should eq({:c => 3, :b => 2, :a => 1})
+        { }.reverse.should eq({ })
+    end
+    specify("#reverse!") do
+        h = {:a => 1, :b => 2, :c => 3}
+        h.reverse!
+        h.should eq({:c => 3, :b => 2, :a => 1})
+        
+        h = { }
+        h.reverse!
+        h.should eq({ })
+    end
+    specify("#some?") do
+        h = {:a => 1, :b => 2, :c => 3}
+        h.some? { |v| v > 1 }.should be_true
+        h.some? { |v| v < 0 }.should be_false
+        { }.some? { |v| b < 0 }.should be_false
+    end
+    specify("#some_pairs?") do
+        h = {:a => 1, :b => 2, :c => 3}
+        h.some_pairs? { |k, v| v > 1 }.should be_true
+        h.some_pairs? { |k, v| k == :a }.should be_true
+        h.some_pairs? { |k, v| k == :d }.should be_false
+        h.some_pairs? { |k, v| v > 4 }.should be_false
+        { }.some_pairs? { |k, v| b < 0 }.should be_false
+    end
+    specify("#sort!") do
+        h = { 3 => :b, 1 => :a,  2 => :c }
+        h.sort!
+        h.should eq({ 1 => :a, 2 => :c, 3 => :b })
+    end
+    specify("#sum") do
+        { :a => 1, :b => 2 }.sum.should eq(3)
+        { :a => "a", :b => "b" }.sum.should eq("ab")
+        {  }.sum.should be_nil
+    end
+    specify("#take_pairs") do
+        h = { :a => 1, :b => 2, :c => 3 }
+        result = [ ]
+        h.take_pairs(:a, :c, :d) { |i| result << i }
+        result.should eq([[:a, 1], [:c, 3], [:d, nil]])
+    end
+    specify("#take_items") do
+        h = { :a => 1, :b => 2, :c => 3 }
+        h.take_items(:a, :c, :d).should eq({ :a => 1, :c => 3, :d => nil })
+    end
+    specify("#take_values") do
+        h = { :a => 1, :b => 2, :c => 3 }
+        h.take_values(:a, :c, :d).should eq([1, 3, nil])
+    end
+    
+end