hashlib 0.0.1

data/lib/hashlib.rb

@@ -0,0 +1,132 @@
+class Hash
+  def diff(other)
+    self.keys.inject({}) do |memo, key|
+      unless self[key] == other[key]
+        if other[key].is_a?(Hash)
+          memo[key] = self[key].diff(other[key])
+        else
+          memo[key] = [self[key], other[key]]
+        end
+      end
+      memo
+    end
+  end
+
+  def get(path, default=nil)
+    root = self
+
+    begin
+      if not path.is_a?(Array)
+        path = path.strip.scan(/[a-z0-9\@\_\-\+]+(?:\[[^\]]+\])?/).to_a
+      end
+
+      path.each do |p|
+        x, key, subfield, subvalue = p.split(/([a-z0-9\@\_\-\+]+)(?:\[([^=]+)(?:=(.+))?\])?/i)
+        root = (root[key] rescue nil)
+        #puts key, root.inspect
+
+        if subfield and root.is_a?(Array)
+          root.each do |r|
+            if r.is_a?(Hash) and r[subfield] and ( (subvalue && r[subfield].to_s == subvalue) || true)
+              root = r
+              break
+            end
+          end
+        end
+      end
+
+      return root || default
+    rescue NoMethodError
+      return default
+    end
+  end
+
+  def set(path, value)
+    if not path.is_a?(Array)
+      path = path.strip.split(/[\/\.]/)
+    end
+    root = self
+
+    path[0..-2].each do |p|
+      root[p] = {} unless root[p].is_a?(Hash)
+      root = root[p]
+    end
+
+    if value
+      root[path.last] = value
+    else
+      root.reject!{|k,v| k.to_sym == path.last.to_sym }
+    end
+
+    self
+  end
+
+  def unset(path)
+    set(path, nil)
+  end
+
+  def rekey(from, to)
+    value = get(from)
+    unset(from)
+    set(to, value)
+  end
+
+  def join(inner_delimiter, outer_delimiter=nil)
+    outer_delimiter = inner_delimiter unless outer_delimiter
+    self.to_a.collect{|i| i.join(inner_delimiter) }.join(outer_delimiter)
+  end
+
+  def coalesce(prefix=nil, base=nil, delimiter='_')
+    base = self unless base
+    rv = {}
+
+    if base.is_a?(Hash)
+      base.each do |k,v|
+        if v
+          base.coalesce(k,v,delimiter).each do |kk,vv|
+            kk = (prefix.to_s+delimiter+kk.to_s) if prefix
+            rv[kk.to_s] = vv
+          end
+        end
+      end
+    else
+      rv[prefix.to_s] = base
+    end
+
+    rv
+  end
+
+  def each_recurse(root=self, path=[], &block)
+    root.each do |k,v|
+      path << k
+
+      if v.is_a?(Hash)
+        each_recurse(v, path, &block)
+      else
+        yield(k, v, path)
+      end
+
+      path.pop
+    end
+  end
+
+  def compact
+    def _is_empty?(i)
+      i === nil or (i.is_a?(String) and i.strip.chomp.empty?) or (i.respond_to?(:empty?) and i.empty?)
+    end
+
+    each_recurse do |k,v,path|
+      path = path.join('.')
+
+      if v.is_a?(Array)
+        v.reject!{|i| _is_empty?(i) }
+        unset(path) if v.empty?
+
+      else
+        unset(path) if _is_empty?(v)
+      end
+    end
+
+    self
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: hashlib
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gary Hetzel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-14 00:00:00.000000000 Z
+dependencies: []
+description: ! "Hashlib: Utility methods for Ruby Hashes\n========================================\n\nHashlib
+  extends the base Ruby Hash class with new methods that offer useful functionality
+  for working with hashes, specifically addressing handling of deeply-nested Hashes
+  for representing rich object structures.\n\nget\n---\n\nThe get method is used to
+  allow for retrieval of a deeply-nested value in a hash structure.\n\nGiven:\n\n```ruby\nconfig
+  = {\n  :global => {\n    :security => {\n      :sslroot => '/etc/ssl'\n    },\n
+  \   :pidfile => '/var/run/example.pid'\n  },\n  :plugins => ['logger', 'cruncher']\n}\n```\n\nThe
+  following statements are equivalent:\n\n```ruby\nconfig.get('global.security.sslroot')\n\n#
+  returns the same thing as\n\nconfig[:global][:security][:sslroot]\n```\n\nHowever,
+  let's say you attempted to get <code>config[:global][:adapters][:path]</code>.  You
+  would get a nasty NilError because <code>:adapters</code> doesn't exist.  However,
+  if you used <code>config.get('global.adapters.path')</code>, the result would just
+  be <code>nil</code>.  _get_ also takes a second argument that let's you specify
+  the default value if the given path is not found.  This lets you very easily work
+  with rich nested hashes while also specifying sane defaults for missing values.\n\n\nset\n---\n\nThe
+  set method is the opposite of get.  It creates one or more intermediary hashes along
+  a specified path and setting the value for the last component.\n\n```ruby\ny = {}\ny.set('this.is.a.number',
+  4)\n\n# results in\n# {\"this\"=>{\n#    \"is\"=>{\n#      \"a\"=>{\n#        \"number\"=>4\n#
+  }}}}\n\n```\n"
+email: garyhetzel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hashlib.rb
+homepage: https://github.com/ghetzel/hashlib
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Useful utility methods for working with Ruby hashes
+test_files: []