bblib 0.3.0 → 0.4.1

data/lib/hash_path/hash_path.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require_relative 'part'
+require_relative 'proc'
+require_relative 'path_hash'
+
+# This classes parses dot delimited hash path strings and wraps the corresponding parts. Then hashes or arrays can be
+# passed to the find method to find all matching elements for the path.
+class HashPath
+  include BBLib::Effortless
+  attr_ary_of Part, :parts, default: []
+
+  def append(path)
+    insert(path, parts.size)
+  end
+
+  def prepend(path)
+    insert(path, 0)
+  end
+
+  def insert(path, index)
+    parse_path(path).each do |part|
+      parts[index] = part
+      index += 1
+    end
+  end
+
+  def find(hash)
+    hash = TreeHash.new unless hash.is_a?(TreeHash)
+    hash.find(self)
+  end
+
+  protected
+
+  def simple_init(*args)
+    args.find_all { |arg| arg.is_a?(String) || arg.is_a?(Symbol) }.each do |path|
+      append(path.to_s)
+    end
+  end
+
+  def parse_path(path)
+    path.to_s.gsub('..', '.[[:recursive:]]').scan(/(?:[\(|\[|\/].*?[\)|\]|\/]|\\\.|[^\.])+/).map do |part|
+      Part.new(part)
+    end
+  end
+end
+
+module BBLib
+  def self.hash_path(hash, *paths, multi_path: false, multi_join: false, multi_join_hash: false)
+    tree = TreeHash.new(hash)
+    if multi_path
+      tree.find_multi(*paths).map  { |r| r.map { |sr| sr&.value } }
+    elsif multi_join
+      tree.find_join(*paths).map { |r| r.map { |sr| sr&.value } }
+    elsif multi_join_hash
+      tree.find_join(*paths).map { |r| r.map { |sr| sr&.value } }.to_h
+    else
+      tree.find(paths).map(&:value)
+    end
+  end
+
+  def self.hash_path_keys(hash)
+    hash.to_tree_hash.absolute_paths
+  end
+
+  def self.hash_path_key_for(hash, value)
+    hash.squish.find_all { |_k, v| value.is_a?(Regexp) ? v =~ value : v == value }.to_h.keys
+  end
+
+  def self.hash_path_set(hash, *paths)
+    tree = hash.is_a?(TreeHash) ? hash : TreeHash.new(hash)
+    tree.bridge(*paths)
+    hash.replace(tree.value)
+  end
+
+  def self.hash_path_copy(hash, *paths)
+    tree = hash.is_a?(TreeHash) ? hash : TreeHash.new(hash)
+    tree.copy(*paths)
+    hash.replace(tree.value)
+  end
+
+  def self.hash_path_copy_to(from, to, *paths)
+    tree = from.is_a?(TreeHash) ? from : TreeHash.new(from)
+    tree.hash_path_copy_to(to, *paths)
+  end
+
+  def self.hash_path_delete(hash, *paths)
+    tree = hash.is_a?(TreeHash) ? hash : TreeHash.new(hash)
+    tree.delete(*paths)
+    hash.replace(tree.value)
+  end
+
+  def self.hash_path_move(hash, *paths)
+    tree = hash.is_a?(TreeHash) ? hash : TreeHash.new(hash)
+    tree.move(*paths)
+    hash.replace(tree.value)
+  end
+
+  def self.hash_path_move_to(from, to, *paths)
+    tree = hash.is_a?(TreeHash) ? hash : TreeHash.new(hash)
+    tree.hash_path_copy_to(to, *paths).tap do |res|
+      from.replace(tree.value)
+      to.replace(res.value)
+    end
+    to
+  end
+
+end
+
+# Monkey patches
+class Hash
+  def hash_path(*path)
+    BBLib.hash_path self, *path
+  end
+
+  def hash_path_set(*paths)
+    BBLib.hash_path_set self, *paths
+  end
+
+  def hash_path_copy(*paths)
+    BBLib.hash_path_copy self, *paths
+  end
+
+  def hash_path_copy_to(to, *paths)
+    BBLib.hash_path_copy_to self, to, *paths
+  end
+
+  def hash_path_delete(*paths)
+    BBLib.hash_path_delete self, *paths
+  end
+
+  def hash_path_move(*paths)
+    BBLib.hash_path_move self, *paths
+  end
+
+  def hash_path_move_to(to, *paths)
+    BBLib.hash_path_move_to self, to, *paths
+  end
+
+  def hash_paths
+    BBLib.hash_path_keys self
+  end
+
+  def hash_path_for(value)
+    BBLib.hash_path_key_for self, value
+  end
+
+  alias hpath hash_path
+  alias hpath_set hash_path_set
+  alias hpath_move hash_path_move
+  alias hpath_move_to hash_path_move_to
+  alias hpath_delete hash_path_delete
+  alias hpath_copy hash_path_copy
+  alias hpath_copy_to hash_path_copy_to
+  alias hpaths hash_paths
+  alias hpath_for hash_path_for
+end
+
+# Monkey Patches
+class Array
+  def hash_path(*path)
+    BBLib.hash_path(self, *path)
+  end
+
+  def hash_path_set(*paths)
+    BBLib.hash_path_set(self, *paths)
+  end
+
+  def hash_path_copy(*paths)
+    BBLib.hash_path_copy(self, *paths)
+  end
+
+  def hash_path_copy_to(to, *paths)
+    BBLib.hash_path_copy_to(self, to, *paths)
+  end
+
+  def hash_path_delete(*paths)
+    BBLib.hash_path_delete(self, *paths)
+  end
+
+  def hash_path_move(*paths)
+    BBLib.hash_path_move(self, *paths)
+  end
+
+  def hash_path_move_to(to, *paths)
+    BBLib.hash_path_move_to(self, to, *paths)
+  end
+
+  def hash_paths
+    BBLib.hash_path_keys(self)
+  end
+
+  def hash_path_for(value)
+    BBLib.hash_path_key_for(self, value)
+  end
+
+  alias hpath hash_path
+  alias hpath_set hash_path_set
+  alias hpath_move hash_path_move
+  alias hpath_move_to hash_path_move_to
+  alias hpath_delete hash_path_delete
+  alias hpath_copy hash_path_copy
+  alias hpath_copy_to hash_path_copy_to
+  alias hpaths hash_paths
+  alias hpath_for hash_path_for
+
+  # Add a hash path to a hash
+  def bridge(*paths)
+    replace(to_tree_hash.bridge(*paths))
+  end
+end

data/lib/hash_path/part.rb

@@ -0,0 +1,83 @@
+class HashPath
+  # This class encapsulates a single portion of a hash path path
+  class Part
+    include BBLib::Effortless
+
+    attr_of [String, Regexp, Integer, Range], :selector, default: nil, allow_nil: true, serialize: true
+    attr_str :evaluation, default: nil, allow_nil: true, serialize: true
+    attr_bool :recursive, default: false, serialize: true
+
+    def parse(path)
+      evl = path.scan(/\(.*\)$/).first
+      self.evaluation = evl ? evl.uncapsulate('(', limit: 1) : evl
+      self.recursive = path.start_with?('[[:recursive:]]')
+      self.selector = parse_selector(evl ? path.sub(evl, '') : path)
+    end
+
+    def key_match?(key, object)
+      case selector
+      when String
+        key.to_s == selector
+      when Integer
+        key.to_i == selector
+      when Range
+        selector === key || object.size.times.to_a.include?(key)
+      else
+        selector === key
+      end
+    end
+
+    def special_selector?
+      selector.is_a?(String) && /^\{.*\}$/ =~ selector
+    end
+
+    def matches(object)
+      matches = []
+      if special_selector?
+        begin
+          [object.send(*selector.uncapsulate('{').split(':'))].flatten(1).compact.each do |match|
+            matches << match if evaluates?(match)
+          end
+        rescue StandardError => e
+          # Nothing, the special selector failed
+          # puts e
+        end
+      elsif object.children?
+        object.children.each do |k, v|
+          matches << v if key_match?(k, object) && evaluates?(v)
+          matches += matches(v) if recursive? && v.children?
+        end
+      end
+      matches
+    end
+
+    def evaluates?(object)
+      return true unless evaluation
+      eval(evaluation.gsub('$', 'object.value'))
+    rescue => e
+      # The eval resulted in an error so we return false
+      false
+    end
+
+    protected
+
+    def simple_init(*args)
+      parse(args.first) if args.first.is_a?(String)
+    end
+
+    def parse_selector(str)
+      str = str.gsub('.[[:recursive:]]', '..') if str =~ /^\[\d+.*\d+\]$/
+      str = str.gsub('[[:recursive:]]', '') if recursive?
+      if str =~ /^\/.*\/[imx]?$/
+        str.to_regex
+      elsif str =~ /^\[\d+\]$/
+        str.uncapsulate('[').to_i
+      elsif str =~ /\[\-?\d+\.{2,3}\-?\d+\]/
+        Range.new(*str.scan(/\-?\d+/).map(&:to_i))
+      else
+        str
+      end.gsub('\\.', '.')
+    end
+
+  end
+end

data/lib/hash_path/path_hash.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# This module provides similar functionality as hash path, but instead
+# generates a PathHash object which wraps a Hash or Array. Elements may
+# be accessed via method calls rather than path strings.
+
+module BBLib
+  def self.path_hash(hash)
+    PathHash.new(hash)
+  end
+
+  # Wraps a hash in a PathHash object which allows ActiveRecord-like access to hash parameters.
+  # For example, methods are treated as keys passed in to Hash's [] method and ._ can be used to
+  # indicate that the next element should be searched for recursively.
+  class PathHash < BasicObject
+    attr_reader :hash, :recursive
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def [](val)
+      PathHash.new(@hash.map { |h| h[val] })
+    end
+
+    def _val
+      @hash
+    end
+
+    alias _v _val
+
+    def _fval
+      @hash.first
+    rescue
+      @hash
+    end
+
+    alias _f _fval
+
+    def _
+      @recursive = true
+      self
+    end
+
+    def _path(arg, formula = nil)
+      method_missing arg, formula
+    end
+
+    # Does not fall back on super as ALL input is accepted
+    def method_missing(arg, formula = nil)
+      arg = (@recursive ? "..#{arg}" : arg.to_s) +
+            (formula ? "(#{formula})" : '')
+      if @hash.is_a?(::Array)
+        PathHash.new @hash.flat_map { |h| if h.is_a?(::Array) || h.is_a?(::Hash) then h.hash_path(arg) end }
+      else
+        PathHash.new @hash.hpath(arg)
+      end
+    end
+
+    def respond_to_missing?(*args)
+      true || super
+    end
+  end
+end
+
+# Monkey Patches
+class Hash
+  def path_hash
+    BBLib.path_hash(self)
+  end
+
+  alias phash path_hash
+  alias _ph path_hash
+end
+
+# Monkey Patches
+class Array
+  def path_hash
+    BBLib.path_hash(self)
+  end
+
+  alias phash path_hash
+  alias _ph path_hash
+end

data/lib/hash_path/proc.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require_relative 'processors'
+
+module BBLib
+  # This class wraps around a hash path or set of paths and maps a set of actions for modifying elements at the matching
+  # path.
+  class HashPathProc
+    include BBLib::Effortless
+
+    attr_ary_of String, :paths, default: [''], serialize: true, uniq: true
+    attr_of [String, Symbol], :action, default: nil, allow_nil: true, serialize: true, pre_proc: proc { |arg| HashPathProc.map_action(arg.to_s.to_sym) }
+    attr_ary :args, default: [], serialize: true
+    attr_hash :options, default: {}, serialize: true
+    attr_of [String, Proc], :condition, default: nil, allow_nil: true, serialize: true
+    attr_bool :recursive, default: false, serialize: true
+    attr_bool :class_based, default: true, serialize: true
+
+    def process(hash)
+      return hash unless @action && hash
+      tree = hash.to_tree_hash
+      paths.each do |path|
+        children = recursive ? tree.find(path).flat_map(&:descendants) : tree.find(path)
+        children.each do |child|
+          next unless check_condition(child.value)
+          HashPathProcs.send(find_action(action), child, *full_args, class_based: class_based)
+        end
+      end
+      hash.replace(tree.value) rescue tree.value
+    end
+
+    def check_condition(value)
+      return true unless condition
+      if condition.is_a?(String)
+        eval(condition)
+      else
+        condition.call(value)
+      end
+    rescue => e
+      false
+    end
+
+    protected
+
+    USED_KEYWORDS = [:action, :args, :paths, :recursive, :condition].freeze
+
+    def find_action(action)
+      (HashPathProcs.respond_to?(action) ? action : :custom)
+    end
+
+    def full_args
+      (HASH_PATH_PROC_TYPES.include?(action) ? [] : [action]) +
+      args +
+      (options.empty? || options.nil? ? [] : [options])
+    end
+
+    def self.map_action(action)
+      clean = HASH_PATH_PROC_TYPES.find { |k, v| action == k || v.include?(action) }
+      clean ? clean.first : action
+    end
+
+    def simple_init(*args)
+      options = BBLib.named_args(*args)
+      options.merge(options.delete(:options)) if options[:options]
+      USED_KEYWORDS.each { |k| options.delete(k) }
+      self.options = options
+      if args.first.is_a?(Symbol) && @action.nil?
+        self.action = args.shift
+        self.paths = args.shift if args.first.is_a?(String)
+      elsif action && args.first.is_a?(String)
+        self.paths = args.first
+      end
+      self.args += args.find_all { |arg| !arg.is_a?(Hash) } unless args.empty?
+    end
+  end
+end
+
+# Monkey patches
+class Hash
+  def hash_path_proc(*args)
+    BBLib::HashPathProc.new(*args).process(self)
+  end
+
+  alias hpath_proc hash_path_proc
+end
+
+# Monkey patches
+class Array
+  def hash_path_proc(*args)
+    BBLib::HashPathProc.new(*args).process(self)
+  end
+
+  alias hpath_proc hash_path_proc
+end