bblib 0.3.0 → 0.4.1

data/lib/hash/bbhash.rb

@@ -1,73 +1,157 @@
-require_relative 'hash_path'
-require_relative 'path_hash'
 
-class Hash
+require_relative 'tree_hash'
+require_relative 'hash_struct'
 
+class Hash
   # Merges with another hash but also merges all nested hashes and arrays/values.
-  # Based on method found @ http://stackoverflow.com/questions/9381553/ruby-merge-nested-hash
-  def deep_merge with, merge_arrays: true, overwrite: true
-      merger = proc{ |k, v1, v2|
-        if v1.is_a?(Hash) && v2.is_a?(Hash)
-          v1.merge(v2, &merger)
-        else
-          if merge_arrays && v1.is_a?(Array) && v2.is_a?(Array)
-            v1 + v2
-          else
-            overwrite || v1 == v2 ? v2 : [v1, v2].flatten
-          end
-        end
-      }
-      self.merge(with, &merger)
-  end
-
-  def deep_merge! with, merge_arrays: true, overwrite: true
-    replace self.deep_merge(with, merge_arrays: merge_arrays, overwrite: overwrite)
+  def deep_merge(with, merge_arrays: true, overwrite: true, uniq: false)
+    merger = proc do |_k, v1, v2|
+      if BBLib.are_all?(Hash, v1, v2)
+        v1.merge(v2, &merger)
+      elsif merge_arrays && BBLib.are_all?(Array, v1, v2)
+        uniq ? (v1 + v2).uniq : v1 + v2
+      else
+        overwrite || v1 == v2 ? v2 : (uniq ? [v1, v2].flatten.uniq : [v1, v2].flatten)
+      end
+    end
+    merge(with, &merger)
+  end
+
+  # In place version of deep_merge
+  def deep_merge!(*args)
+    replace deep_merge(*args)
   end
 
   # Converts the keys of the hash as well as any nested hashes to symbols.
-  # Based on method found @ http://stackoverflow.com/questions/800122/best-way-to-convert-strings-to-symbols-in-hash
-  def keys_to_sym clean: false
-    self.inject({}){|memo,(k,v)| memo[clean ? k.to_s.to_clean_sym : k.to_s.to_sym] = (v.is_a?(Hash) || v.is_a?(Array) ? v.keys_to_sym(clean:clean) : v); memo}
+  def keys_to_sym(clean: false, recursive: true)
+    each_with_object({}) do |(k, v), memo|
+      key = clean ? k.to_s.to_clean_sym : k.to_s.to_sym
+      memo[key] = recursive && v.respond_to?(:keys_to_sym) ? v.keys_to_sym(clean: clean) : v
+    end
   end
 
-  def keys_to_sym! clean: false
-    replace(self.keys_to_sym clean:clean)
+  # In place version of keys_to_sym
+  def keys_to_sym!(clean: false, recursive: true)
+    replace(keys_to_sym(clean: clean, recursive: recursive))
   end
 
   # Converts the keys of the hash as well as any nested hashes to strings.
-  def keys_to_s
-    self.inject({}){|memo,(k,v)| memo[k.to_s] = (v.is_a?(Hash) || v.is_a?(Array) ? v.keys_to_s : v); memo}
+  def keys_to_s(recursive: true)
+    each_with_object({}) do |(k, v), memo|
+      memo[k.to_s] = recursive && v.respond_to?(:keys_to_sym) ? v.keys_to_s : v
+    end
   end
 
-  def keys_to_s!
-    replace(self.keys_to_s)
+  # In place version of keys_to_s
+  def keys_to_s!(recursive: true)
+    replace(keys_to_s(recursive: recursive))
   end
 
   # Reverses the order of keys in the Hash
   def reverse
-    self.to_a.reverse.to_h
+    to_a.reverse.to_h
   end
 
+  # In place version of reverse
   def reverse!
-    replace self.reverse
+    replace(reverse)
+  end
+
+  # Like unshift for Arrays. Adds a key to the beginning of a Hash rather than the end.
+  def unshift(hash, value = nil)
+    hash = { hash => value } unless hash.is_a?(Hash)
+    replace(hash.merge(self).merge(hash))
+  end
+
+  # Displays all of the differences between this hash and another.
+  # Checks both key and value pairs.
+  def diff(hash)
+    to_a.diff(hash.to_a).to_h
+  end
+
+  # Returns all matching values with a specific key (or keys) recursively within a Hash (including nested Arrays)
+  def dive(*keys)
+    matches = []
+    each do |k, v|
+      matches << v if keys.any? { |key| (key.is_a?(Regexp) ? key =~ k : key == k) }
+      matches += v.dive(*keys) if v.respond_to?(:dive)
+    end
+    matches
+  end
+
+  # Navigate a hash using a dot delimited path.
+  def path_nav(obj, path = '', delimiter = '.', &block)
+    case obj
+    when Hash
+      obj.each do |k, v|
+        path_nav(
+          v,
+          (path ? [path, k.to_s.gsub(delimiter, "\\#{delimiter}")].join(delimiter) : k.to_s.gsub(delimiter, "\\#{delimiter}")).to_s,
+          delimiter,
+          &block
+        )
+      end
+    when Array
+      obj.each_with_index do |ob, index|
+        path_nav(
+          ob,
+          (path ? [path, "[#{index}]"].join(delimiter) : "[#{index}]").to_s,
+          delimiter,
+          &block
+        )
+      end
+    else
+      yield path, obj
+    end
   end
 
-  def unshift hash, value = nil
-    hash = {hash => value} if !hash.is_a? Hash
-    replace hash.merge(self).merge(hash)
+  # Turns nested values' keys into delimiter separated paths
+  def squish(delimiter: '.')
+    sh = {}
+    path_nav(dup, nil, delimiter) { |k, v| sh[k] = v }
+    sh
   end
 
-  def to_xml level: 0, key:nil
-    map do |k,v|
-      nested = v.respond_to?(:to_xml)
-      array = v.is_a?(Array)
-      value = nested ? v.to_xml(level:level + (array ? 0 : 1), key:k) : v
-      (array ? '' : ("\t" * level + "<#{k}>\n")) +
-      (nested ? '' : "\t" * (level + 1)) +
-      "#{value}\n" +
-      "\t" * level +
-      (array ? '' : "</#{k}>\n")
-    end.join.split("\n").reject{ |r| r.strip == '' }.join("\n")
+  # Expands keys in a hash using a delimiter. Opposite of squish.
+  def expand
+    {}.to_tree_hash.tap do |hash|
+      each do |k, v|
+        hash.bridge(k => v)
+      end
+    end.value
   end
 
+  # Returns a version of the hash not including the specified keys
+  def only(*args)
+    select { |k, _v| args.include?(k) }
+  end
+
+  # Returns a version of the hash with the specified keys removed.
+  def except(*args)
+    reject { |k, _v| args.include?(k) }
+  end
+
+  # Convert this hash into a TreeHash object.
+  def to_tree_hash
+    TreeHash.new(self)
+  end
+
+  # Run a map iterator over the values in the hash without changing the keys.
+  def vmap
+    return map unless block_given?
+    map { |k, v| [k, yield(v)] }.to_h
+  end
+
+  # Run a map iterator over the keys in the hash without changing the values.
+  def kmap
+    return map unless block_given?
+    map { |k, v| [yield(k), v] }.to_h
+  end
+
+  # Map for hash that automatically converts the yield block to a hash.
+  # Each yield must produce an array with exactly two elements.
+  def hmap
+    return map unless block_given?
+    map { |k, v| yield(k, v) }.to_h
+  end
 end

data/lib/hash/hash_struct.rb

@@ -0,0 +1,24 @@
+# Similar to Ruby's OpenStruct but uses hash as its parent class providing
+# all of the typical Hash methods. Useful for storing settings on objects.
+module BBLib
+  class HashStruct < Hash
+
+    protected
+
+    def method_missing(method, *args, &block)
+      if args.empty?
+        define_singleton_method(method) do
+          self[method]
+        end
+        self[method]
+      elsif method.to_s.end_with?('=')
+        define_singleton_method(method) do |arg|
+          self[method[0..-2].to_sym] = arg
+        end
+        self[method[0..-2].to_sym] = args.first
+      else
+        super
+      end
+    end
+  end
+end

data/lib/hash/tree_hash.rb

@@ -0,0 +1,364 @@
+class TreeHash
+  attr_reader :node_class, :parent, :children
+
+  def initialize(object = {}, parent = nil)
+    @children = {}
+    @parent   = parent
+    object    = object.value if object.is_a?(TreeHash)
+    replace_with(object)
+  end
+
+  def replace_with(object)
+    @node_class = object.class
+    build_from(object)
+  end
+
+  def root?
+    @parent.nil?
+  end
+
+  def child?
+    !root?
+  end
+
+  def child(key, symbol_sensitive = false)
+    case [node_class]
+    when [Hash]
+      children[key] || (symbol_sensitive ? nil : children[key.to_s.to_sym])
+    when [Array]
+      children[key.to_i]
+    else
+      nil
+    end
+  end
+
+  def child_exists?(key, symbol_sensitive = false)
+    !case [node_class]
+    when [Hash]
+      children[key] || (!symbol_sensitive && children[key.to_s.to_sym])
+    when [Array]
+      [0...children.size] === key.to_i
+    else
+      false
+    end.nil?
+  end
+
+  def children?
+    (node_class == Hash || node_class == Array) && !children.empty?
+  end
+
+  def descendants
+    return [] unless children?
+    desc = []
+    children.each do |key, child|
+      desc << child
+      desc += child.descendants if child.children?
+    end
+    desc
+  end
+
+  def [](key)
+    children[key]
+  end
+
+  def []=(key, value)
+    add_child(key, value)
+  end
+
+  def find(path)
+    path = HashPath.new(*path) unless path.is_a?(HashPath)
+    matches = [self]
+    path.parts.each do |part|
+      break if matches.empty?
+      matches = matches.flat_map do |match|
+        part.matches(match)
+      end
+    end
+    matches
+  end
+
+  def find_multi(*paths)
+    paths.map do |path|
+      find(path)
+    end
+  end
+
+  def find_join(*paths)
+    results = find_multi(*paths)
+    (0..(results.max_by(&:size).size - 1)).map do |index|
+      results.map do |result|
+        result[index]
+      end
+    end
+  end
+
+  def find_join_hash(key_path, val_path)
+    find_join(key_path, val_path).to_h
+  end
+
+  def set(paths)
+    paths.each do |path, value|
+      find(path).each { |child| child.replace_with(value) }
+    end
+    self
+  end
+
+  # Generate a path using a dot (.) delimited path
+  # e.g. bridge('cats.jackson' => :my_value)
+  # This modifies the underlying container in place
+  def bridge(paths)
+    paths = paths.map { |a| [a, nil] }.to_h if paths.is_a?(Array)
+    paths.each do |path, value|
+      parts     = path.to_s.split(/(?<=[^\\])\./)
+      node      = self
+      next_part = false
+      until next_part.nil?
+        part      = next_part || process_bridge_part(parts.shift)
+        next_part = process_bridge_part(parts.shift)
+        if node.child_exists?(part)
+          if next_part.is_a?(Integer)
+            next_next = process_bridge_part(parts.first)
+            if next_next.is_a?(Integer)
+              node[part][next_part] = [] unless node[part][next_part] && node[part][next_part].node_class == Array
+            else
+              node[part][next_part] = {} unless node[part][next_part] && node[part][next_part].node_class == Hash
+            end
+          end
+          next_part.nil? ? node[part] = value : node = node.child(part)
+        else
+          if next_part.nil?
+            node[part] = value
+          else
+            node[part] = next_part.is_a?(Integer) ? Array.new(next_part) : {}
+          end
+          node[part][next_part] = process_bridge_part(parts.first).is_a?(Integer) ? [] : {} if next_part.is_a?(Integer)
+          node = node[part]
+        end
+      end
+    end
+    self
+  end
+
+  def copy(paths)
+    paths.each do |from, to|
+      value = find(from).first
+      bridge(to => value)
+    end
+    self
+  end
+
+  def copy_all(paths)
+    paths.each do |from, to|
+      value = find(from)
+      bridge(to => value)
+    end
+    self
+  end
+
+  def move(paths)
+    paths.each do |from, to|
+      values = find(from)
+      next if values.empty?
+      value = values.first
+      bridge(to => value)
+      value.kill if value
+    end
+    self
+  end
+
+  def move_all(paths)
+    paths.each do |from, to|
+      value = find(from)
+      bridge(to => value)
+      value.map(&:kill)
+    end
+    self
+  end
+
+  def copy_to(hash, *paths)
+    hash = TreeHash.new(hash) unless hash.is_a?(TreeHash)
+    paths.each do |path|
+      hash.bridge(path => find(path).first)
+    end
+    hash
+  end
+
+  def move_to(hash, *paths)
+    hash = TreeHash.new(hash) unless hash.is_a?(TreeHash)
+    paths.each do |path|
+      value = find(path).first
+      hash.bridge(path => value)
+      value.kill if value
+    end
+    hash
+  end
+
+  def to_tree_hash
+    self
+  end
+
+  def process(processor)
+
+  end
+
+  def size
+    @children.respond_to?(:size) ? @children.size : 1
+  end
+
+  def paths
+    case [node_class]
+    when [Array], [Hash]
+      value.squish.keys
+    else
+      []
+    end
+  end
+
+  def ancestors
+    return [] if root?
+    return [parent] if parent.root?
+    parent.ancestors + [parent]
+  end
+
+  def absolute_path
+    anc = ancestors[1..-1]
+    (anc.nil? ? [] : anc.map(&:path) + [path]).join('.')
+  end
+
+  def inspect
+    value
+  end
+
+  def to_s
+    value.to_s
+  end
+
+  def siblings
+    parent.children.values.map { |c| c == self ? nil : c }.compact
+  end
+
+  def index
+    parent.children.values.index(self)
+  end
+
+  def delete(*paths)
+    paths.flat_map do |path|
+      find(path).map do |child|
+        if child.root?
+          delete_child(path)
+        else
+          child.parent.delete_child(child.key)
+        end
+      end
+    end
+  end
+
+  def kill
+    root.delete(absolute_path)
+  end
+
+  def value
+    case [node_class]
+    when [Hash]
+      children.map { |k, v| [k, v.value] }.to_h
+    when [Array]
+      children.values.map(&:value)
+    else
+      children
+    end
+  end
+
+  def key
+    return nil if root?
+    case [parent.node_class]
+    when [Hash]
+      parent.keys[index]
+    when [Array]
+      index
+    else
+      nil
+    end
+  end
+
+  def path
+    parent.node_class == Array ? "[#{key}]" : key.to_s.gsub('.', '\\.')
+  end
+
+  def absolute_paths
+    root.paths
+  end
+
+  def leaf_children
+    return self unless children?
+    children.map do |k, v|
+      v.children? ? v.leaf_children : v
+    end.flatten
+  end
+
+  def keys
+    return [] unless @children.respond_to?(:keys)
+    @children.keys
+  end
+
+  def following_siblings(limit = 0)
+    siblings[(index + 1)..-(limit.to_i + 1)]
+  end
+
+  def preceeding_siblings(limit = 0)
+    limit = limit.to_i
+    siblings[(limit.zero? ? limit : (index - limit))..(index - 1)]
+  end
+
+  def sibling(offset)
+    siblings[index + offset.to_i]
+  end
+
+  def next_sibling
+    sibling(1)
+  end
+
+  def previous_sibling
+    sibling(-1)
+  end
+
+  def root
+    return self if root?
+    ancestors.find(&:root?)
+  end
+
+  def delete_child(key, symbol_sensitive = false)
+    case [node_class]
+    when [Hash]
+      child = symbol_sensitive ? nil : children.delete(key.to_s.to_sym)
+      child = children.delete(key) unless child
+    when [Array]
+      children.delete(key.to_i)
+    else
+      nil
+    end
+  end
+
+  protected
+
+  def build_from(object)
+    @children = {}
+    case object
+    when Hash
+      object.each { |k, v| @children[k] = TreeHash.new(v, self) }
+    when Array
+      object.each_with_index { |a, i| @children[i] = TreeHash.new(a, self) }
+    else
+      @children = object
+    end
+  end
+
+  def add_child(key, child)
+    @children[key] = TreeHash.new(child, self)
+  end
+
+  def process_bridge_part(part)
+    return unless part
+    part =~ /^\[\d+\]$/ ? part.uncapsulate('[').to_i : part.to_sym
+  end
+
+end