hash-utils 0.2.0 → 0.3.0

data/Gemfile

@@ -1,7 +1,7 @@
 source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
-#   gem "activesupport", ">= 2.3.5"
+#   gem "multitype-introspection", ">= 0.1.0"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/README.md

@@ -12,6 +12,7 @@ class to [Hash][2] class. Extends them with following methods:
 * `#map_keys!`
 * `#keys_to_sym` – converts all keys to [Symbols][6],
 * `#keys_to_sym!`
+* …
 
 All methods with `!` emulates work *in place*, but in fact they 
 replace old hash with new one. An example of use: 
@@ -25,16 +26,38 @@ replace old hash with new one. An example of use:
 This is the same as `#keys_to_sym!` for example. And also introduces
 some methods known from Python to both [Array][1] and [Hash][2] class:
 
-* `some?` –  returns `true` if *some* element follows condition in block,
+* `some?` – returns `true` if *some* element follows condition in block,
 * `some_pairs?`
-* `all?` –  returns `true` if *all* element follows condition in block,
+* `all?` – returns `true` if *all* element follows condition in block,
 * `all_pairs?`
 
 For example:
 
     foo = [:alfa, :beta, 5, :gama]
-    foo.some? { |i| i.kind_of? Integer }    # returns true
+    foo.some? { |i| i.kind_of? Numeric }    # returns true
     foo.all? { |i| i.kind_of? Symbol }      # returns false
+    
+And finally introduces one method to [Numeric][7], [Symbol][6] and 
+[String][8]:
+
+* `in?` – returns `true` if value is in some Object which support 
+`include?` method
+
+For example:
+    
+    foo = [1, 2, 3, 5, 8]
+    5.in? foo       # returns true
+    5.in? 3..6      # returns true
+    
+As you can see, it's syntactic sugar, of sure, but useful in some cases.
+Except these, it adds many other useful metods. See documentation.
+
+### Modularization
+
+If you don't want to include whole library, you can include extensions 
+to appropriate type only by including the:
+
+    require "hash-utils/<lowercase-data-type-name>"
 
 Contributing
 ------------
@@ -43,14 +66,14 @@ Contributing
 2. Create a branch (`git checkout -b 20101220-my-change`).
 3. Commit your changes (`git commit -am "Added something"`).
 4. Push to the branch (`git push origin 20101220-my-change`).
-5. Create an [Issue][7] with a link to your branch.
+5. Create an [Issue][9] with a link to your branch.
 6. Enjoy a refreshing Diet Coke and wait.
 
 
 Copyright
 ---------
 
-Copyright &copy; 2011 [Martin Kozák][8]. See `LICENSE.txt` for
+Copyright &copy; 2011 [Martin Kozák][10]. See `LICENSE.txt` for
 further details.
 
 [1]: http://www.ruby-doc.org/core/classes/Array.html
@@ -59,5 +82,7 @@ further details.
 [4]: http://www.ruby-doc.org/core/classes/Array.html#M000279
 [5]: http://www.ruby-doc.org/core/classes/Array.html#M000249
 [6]: http://www.ruby-doc.org/core/classes/Symbol.html
-[7]: http://github.com/martinkozak/hash-utils/issues
-[8]: http://www.martinkozak.net/
+[7]: http://www.ruby-doc.org/core/classes/Numeric.html
+[8]: http://www.ruby-doc.org/core/classes/String.html
+[9]: http://github.com/martinkozak/hash-utils/issues
+[10]: http://www.martinkozak.net/

data/Rakefile

@@ -16,7 +16,7 @@ Jeweler::Tasks.new do |gem|
   gem.name = "hash-utils"
   gem.homepage = "http://github.com/martinkozak/hash-utils"
   gem.license = "MIT"
-  gem.summary = 'Adds some useful well known methods similar to appropriate Array methods to Hash and some useful methods known from Python to both of them.'
+  gem.summary = 'Adds some useful well known methods similar to appropriate Array methods to Hash and some useful methods known from Python to both of them. Also defines some utility method for other data types.'
   gem.email = "martinkozak@martinkozak.net"
   gem.authors = ["Martin Kozák"]
   # Include your dependencies below. Runtime dependencies are required when using your gem,

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/hash-utils.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hash-utils}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Martin Kozák"]
-  s.date = %q{2011-01-04}
+  s.date = %q{2011-01-12}
   s.email = %q{martinkozak@martinkozak.net}
   s.extra_rdoc_files = [
     "LICENSE.txt",
@@ -24,13 +24,18 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "hash-utils.gemspec",
-    "lib/hash-utils.rb"
+    "lib/hash-utils.rb",
+    "lib/hash-utils/array.rb",
+    "lib/hash-utils/hash.rb",
+    "lib/hash-utils/numeric.rb",
+    "lib/hash-utils/string.rb",
+    "lib/hash-utils/symbol.rb"
   ]
   s.homepage = %q{http://github.com/martinkozak/hash-utils}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Adds some useful well known methods similar to appropriate Array methods to Hash and some useful methods known from Python to both of them.}
+  s.summary = %q{Adds some useful well known methods similar to appropriate Array methods to Hash and some useful methods known from Python to both of them. Also defines some utility method for other data types.}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/lib/hash-utils.rb

@@ -1,206 +1,8 @@
 # encoding: utf-8
 # (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
 
-class Hash
-
-    ##
-    # Returns a copy of <tt>self</tt> with all <tt>nil</tt> 
-    # elements removed.
-    #
-
-    def compact
-        self.reject { |k, v| v.nil? }
-    end
-    
-    ##
-    # Removes <tt>nil</tt> elements from the hash. Returns <tt>nil</tt> 
-    # if no changes were made, otherwise returns <tt>self</self>.
-    #
-    
-    def compact!
-        self.reject! { |k, v| v.nil? }
-    end
-    
-    ##
-    # Returns a new hash with the results of running block once for 
-    # every pair in <tt>self</tt>.
-    # 
-    
-    def map_pairs(&block)
-        new = Hash::new(&self.default_proc)
-        new.default = self.default
-        
-        self.each_pair do |k, v|
-            new_k, new_v = block.call(k, v)
-            new[new_k] = new_v
-        end
-        
-        return new
-    end
-    
-    alias :collect_pairs :map_pairs
-    
-    ##
-    # Emulates #map_pairs on place. In fact, replaces old hash by 
-    # new one.
-    #
-    
-    def map_pairs!(&block)
-        self.replace(self.map_pairs(&block))
-    end
-    
-    alias :"collect_pairs!" :"map_pairs!"
-    
-    ##
-    # Returns a new hash with the results of running block once for 
-    # every key in <tt>self</tt>.
-    #
-    
-    def map_keys(&block)
-        self.map_pairs do |k, v|
-            [block.call(k), v]
-        end
-    end
-    
-    alias :collect_keys :map_keys
-    
-    ##
-    # Emulates #map_keys on place. In fact, replaces old hash by 
-    # new one.
-    #
-    
-    def map_keys!(&block)
-        self.replace(self.map_keys(&block))
-    end
-    
-    alias :"collect_keys!" :"map_keys!"
-    
-    ##
-    # Converts all keys to symbols.
-    #
-    
-    def keys_to_sym
-        self.map_keys { |k| k.to_sym }
-    end
-    
-    ##
-    # Emulates #keys_to_sym on place. In fact, replaces old hash by 
-    # new one.
-    #
-    
-    def keys_to_sym!
-        self.replace(self.keys_to_sym)
-    end
-    
-    ##
-    # Checks, all elements values follow condition expressed in block.
-    # Block must return Boolean.
-    #
-    # If it's empty, returns <tt>true</tt>.
-    #
-    
-    def all?(&block)
-        if self.empty?
-            return true
-        end
-        
-        self.each_value do |v|
-            if block.call(v) == false
-                return false
-            end
-        end
-        
-        return true
-    end
-        
-    ##
-    # Checks, all elements follow condition expressed in block.
-    # Block must return Boolean.
-    #
-    # If it's empty, returns <tt>true</tt>.
-    #
-    
-    def all_pairs?(&block)
-        if self.empty?
-            return true
-        end
-        
-        self.each_pair do |k, v|
-            if block.call(k, v) == false
-                return false
-            end
-        end
-        
-        return true
-    end
-    
-    ##
-    # Checks, at least one element value follows condition expressed in 
-    # block. Block must return Boolean.
-    #
-    
-    def some?(&block)
-        self.each_value do |v|
-            if block.call(v) == true
-                return true
-            end
-        end
-        
-        return false
-    end
-
-    ##
-    # Checks, at least one element follows condition expressed in 
-    # block. Block must return Boolean.
-    #
-        
-    def some_pairs?(&block)
-        self.each_pair do |k, v|
-            if block.call(k, v) == true
-                return true
-            end
-        end
-        
-        return false
-    end
-end
-
-class Array
-
-    ##
-    # Checks, all values follow condition expressed in block.
-    # Block must return Boolean.
-    #
-    # If it's empty, returns <tt>true</tt>.
-    #
-    
-    def all?(&block)
-        if self.empty?
-            return true
-        end
-        
-        self.each do |v|
-            if block.call(v) == false
-                return false
-            end
-        end
-        
-        return true
-    end
-
-    ##
-    # Checks, at least one value follows condition expressed in 
-    # block. Block must return Boolean.
-    #
-    
-    def some?(&block)
-        self.each do |v|
-            if block.call(v) == true
-                return true
-            end
-        end
-        
-        return false
-    end
-
-end
+require "hash-utils/array"
+require "hash-utils/hash"
+require "hash-utils/numeric"
+require "hash-utils/string"
+require "hash-utils/symbol"

data/lib/hash-utils/array.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+class Array
+
+    ##
+    # Moves selected values outside the array, so returns them.
+    #
+    # Works similar to #reject!, but returns removed items instead 
+    # of remaining items.
+    #
+    
+    def remove!(&block)
+        result = [ ]
+        self.reject! do |v|
+            if block.call(v)
+                result << v
+                true
+            else
+                false
+            end
+        end
+        
+        return result
+    end
+
+    ##
+    # Checks, all values follow condition expressed in block.
+    # Block must return Boolean.
+    #
+    # If it's empty, returns <tt>true</tt>.
+    #
+    
+    def all?(&block)
+        if self.empty?
+            return true
+        end
+        
+        self.each do |v|
+            if block.call(v) == false
+                return false
+            end
+        end
+        
+        return true
+    end
+
+    ##
+    # Checks, at least one value follows condition expressed in 
+    # block. Block must return Boolean.
+    #
+    
+    def some?(&block)
+        self.each do |v|
+            if block.call(v) == true
+                return true
+            end
+        end
+        
+        return false
+    end
+
+end

data/lib/hash-utils/hash.rb

@@ -0,0 +1,229 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+class Hash
+
+    ##
+    # Defines hash by setting the default value or Proc and content.
+    #
+    
+    def self.define(values = { }, default = nil, &block) 
+        hash = self[values]
+        self::create(default, hash, &block)
+    end
+    
+    ##
+    # Creates hash by setting default settings in one call.
+    #
+    
+    def self.create(default = nil, hash = { }, &block)
+        hash.default = default
+        
+        if not block.nil?
+            hash.default_proc = block
+        end
+        
+        return hash        
+    end
+
+    ##
+    # Recreates the hash, so creates empty one and assigns
+    # the same default values.
+    #
+    
+    def recreate
+        self.class::create(self.default, &self.default_proc)
+    end
+    
+    ##
+    # Recreates the hash in place, so creates empty one, assigns
+    # the same default values and replaces the old one.
+    #
+    
+    def recreate!
+        self.replace(self.recreate)
+    end
+
+    ##
+    # Moves selected pairs outside the hash, so returns them.
+    # Output hash has the same default settings.
+    #
+    
+    def remove!(&block)
+        result = self.recreate
+        delete = [ ]
+        
+        self.each_pair do |k, v|
+            if block.call(k, v)
+                result[k] = v
+                delete << k
+            end
+        end
+        
+        delete.each do |k|
+            self.delete(k)
+        end
+        
+        return result
+    end
+
+    ##
+    # Returns a copy of <tt>self</tt> with all <tt>nil</tt> 
+    # elements removed.
+    #
+
+    def compact
+        self.reject { |k, v| v.nil? }
+    end
+    
+    ##
+    # Removes <tt>nil</tt> elements from the hash. Returns <tt>nil</tt> 
+    # if no changes were made, otherwise returns <tt>self</self>.
+    #
+    
+    def compact!
+        self.reject! { |k, v| v.nil? }
+    end
+    
+    ##
+    # Returns a new hash with the results of running block once for 
+    # every pair in <tt>self</tt>.
+    # 
+    
+    def map_pairs(&block)
+        new = self.recreate
+        
+        self.each_pair do |k, v|
+            new_k, new_v = block.call(k, v)
+            new[new_k] = new_v
+        end
+        
+        return new
+    end
+    
+    alias :collect_pairs :map_pairs
+    
+    ##
+    # Emulates #map_pairs on place. In fact, replaces old hash by 
+    # new one.
+    #
+    
+    def map_pairs!(&block)
+        self.replace(self.map_pairs(&block))
+    end
+    
+    alias :"collect_pairs!" :"map_pairs!"
+    
+    ##
+    # Returns a new hash with the results of running block once for 
+    # every key in <tt>self</tt>.
+    #
+    
+    def map_keys(&block)
+        self.map_pairs do |k, v|
+            [block.call(k), v]
+        end
+    end
+    
+    alias :collect_keys :map_keys
+    
+    ##
+    # Emulates #map_keys on place. In fact, replaces old hash by 
+    # new one.
+    #
+    
+    def map_keys!(&block)
+        self.replace(self.map_keys(&block))
+    end
+    
+    alias :"collect_keys!" :"map_keys!"
+    
+    ##
+    # Converts all keys to symbols.
+    #
+    
+    def keys_to_sym
+        self.map_keys { |k| k.to_sym }
+    end
+    
+    ##
+    # Emulates #keys_to_sym on place. In fact, replaces old hash by 
+    # new one.
+    #
+    
+    def keys_to_sym!
+        self.replace(self.keys_to_sym)
+    end
+    
+    ##
+    # Checks, all elements values follow condition expressed in block.
+    # Block must return Boolean.
+    #
+    # If it's empty, returns <tt>true</tt>.
+    #
+    
+    def all?(&block)
+        if self.empty?
+            return true
+        end
+        
+        self.each_value do |v|
+            if block.call(v) == false
+                return false
+            end
+        end
+        
+        return true
+    end
+        
+    ##
+    # Checks, all elements follow condition expressed in block.
+    # Block must return Boolean.
+    #
+    # If it's empty, returns <tt>true</tt>.
+    #
+    
+    def all_pairs?(&block)
+        if self.empty?
+            return true
+        end
+        
+        self.each_pair do |k, v|
+            if block.call(k, v) == false
+                return false
+            end
+        end
+        
+        return true
+    end
+    
+    ##
+    # Checks, at least one element value follows condition expressed in 
+    # block. Block must return Boolean.
+    #
+    
+    def some?(&block)
+        self.each_value do |v|
+            if block.call(v) == true
+                return true
+            end
+        end
+        
+        return false
+    end
+
+    ##
+    # Checks, at least one element follows condition expressed in 
+    # block. Block must return Boolean.
+    #
+        
+    def some_pairs?(&block)
+        self.each_pair do |k, v|
+            if block.call(k, v) == true
+                return true
+            end
+        end
+        
+        return false
+    end
+end

data/lib/hash-utils/numeric.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+class Numeric
+    ##
+    # Indicates numeric is in some object which supports #include?.
+    #
+    
+    def in?(range)
+        range.include? self
+    end
+end

data/lib/hash-utils/string.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+class String
+    ##
+    # Holds numeric matcher.
+    #
+    
+    NUMERIC = /^\s*-?\d+(?:\.\d+)?\s*$/
+    
+    ##
+    # Indicates string is in some object which supports #include?.
+    #
+    
+    def in?(range)
+        range.include? self
+    end
+    
+    ##
+    # Indicates, string is numeric, so consists of numbers only.
+    #
+    
+    def numeric?
+        if self.match(self.class::NUMERIC)
+            true
+        else
+            false
+        end
+    end
+end

data/lib/hash-utils/symbol.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+class Symbol
+    ##
+    # Indicates symbol is in some object which supports #include?.
+    #
+    
+    def in?(range)
+        range.include? self
+    end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - "Martin Koz\xC3\xA1k"
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-04 00:00:00 +01:00
+date: 2011-01-12 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -66,6 +66,11 @@ files:
 - VERSION
 - hash-utils.gemspec
 - lib/hash-utils.rb
+- lib/hash-utils/array.rb
+- lib/hash-utils/hash.rb
+- lib/hash-utils/numeric.rb
+- lib/hash-utils/string.rb
+- lib/hash-utils/symbol.rb
 has_rdoc: true
 homepage: http://github.com/martinkozak/hash-utils
 licenses: 
@@ -80,7 +85,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3013449918055684649
+      hash: -3600041208124521153
       segments: 
       - 0
       version: "0"
@@ -98,6 +103,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Adds some useful well known methods similar to appropriate Array methods to Hash and some useful methods known from Python to both of them.
+summary: Adds some useful well known methods similar to appropriate Array methods to Hash and some useful methods known from Python to both of them. Also defines some utility method for other data types.
 test_files: []