kronk 1.5.4 → 1.6.0

data/lib/kronk/path/matcher.rb

@@ -0,0 +1,189 @@
+##
+# Path::Matcher is representation of a single node of a relative path used
+# to find values in a data set.
+
+class Kronk::Path::Matcher
+
+  # Used as path item value to match any key or value.
+  module ANY_VALUE; end
+
+  # Shortcut characters that require modification before being turned into
+  # a matcher.
+  SUFF_CHARS = Regexp.escape "*?"
+
+  # All special path characters.
+  PATH_CHARS = Regexp.escape("()|") << SUFF_CHARS
+
+  # Path chars that get regexp escaped.
+  RESC_CHARS = "*?()|/"
+
+  # Matcher for Range path item.
+  RANGE_MATCHER  = %r{^(\-?\d+)(\.{2,3})(\-?\d+)$}
+
+  # Matcher for index,length path item.
+  ILEN_MATCHER   = %r{^(\-?\d+),(\-?\d+)$}
+
+  # Matcher allowing any value to be matched.
+  ANYVAL_MATCHER = /^(\?*\*+\?*)*$/
+
+  # Matcher to assert if any unescaped special chars are in a path item.
+  PATH_CHAR_MATCHER = /(^|[^#{Kronk::Path::RECH}])([#{PATH_CHARS}])/
+
+
+  attr_reader :key, :value, :regex_opts
+
+  def initialize opts={}
+    @regex_opts = opts[:regex_opts]
+    @recursive  = !!opts[:recursive]
+
+    @key = nil
+    @key = parse_node opts[:key] if
+      opts[:key] && !opts[:key].to_s.empty?
+
+    @value = nil
+    @value = parse_node opts[:value] if
+      opts[:value] && !opts[:value].to_s.empty?
+  end
+
+
+  def == other # :nodoc:
+    self.class  == other.class      &&
+    @key        == other.key        &&
+    @value      == other.value      &&
+    @regex_opts == other.regex_opts
+  end
+
+
+  ##
+  # Universal iterator for Hash and Array like objects.
+  # The data argument must either respond to both :each_with_index
+  # and :length, or respond to :each yielding a key/value pair.
+
+  def each_data_item data, &block
+    if data.respond_to?(:has_key?) && data.respond_to?(:each)
+      data.each(&block)
+
+    elsif data.respond_to?(:each_with_index) && data.respond_to?(:length)
+      # We need to iterate through the array this way
+      # in case items in it get deleted.
+      (data.length - 1).downto(0) do |i|
+        block.call i, data[i]
+      end
+    end
+  end
+
+
+  ##
+  # Finds data with the given key and value matcher, optionally recursively.
+  # Yields data, key and path Array when block is given.
+  # Returns an Array of path arrays.
+
+  def find_in data, path=nil, &block
+    return [] unless Array === data || Hash === data
+
+    paths  = []
+    path ||= Kronk::Path::PathMatch.new
+    path   = Kronk::Path::PathMatch.new path if path.class == Array
+
+    each_data_item data do |key, value|
+      c_path = path.dup << key
+
+      found, kmatch = match_node(@key, key)     if @key
+      found, vmatch = match_node(@value, value) if @value && (!@key || found)
+
+      if found
+        c_path.matches.concat kmatch.to_a
+        c_path.matches.concat vmatch.to_a
+
+        yield data, key, c_path if block_given?
+        paths << c_path
+      end
+
+      paths.concat \
+        find_in(data[key], c_path, &block) if @recursive
+    end
+
+    paths
+  end
+
+
+  ##
+  # Check if data key or value is a match for nested data searches.
+  # Returns an array with a boolean expressing if the value matched the node,
+  # and the matches found.
+
+  def match_node node, value
+    return if ANY_VALUE != node &&
+              (Array === value || Hash === value)
+
+    if node.class == value.class
+      node == value
+
+    elsif Regexp === node
+      match = node.match value.to_s
+      return false unless match
+      match = match.size > 1 ? match[1..-1] : match.to_a
+      [true, match]
+
+    elsif Range === node
+      stat  = node.include? value.to_i
+      match = [value.to_i] if stat
+      [stat, match]
+
+    elsif ANY_VALUE == node
+      [true, [value]]
+
+    else
+      value.to_s == node.to_s
+    end
+  end
+
+
+  ##
+  # Decide whether to make path item matcher a regex, range, array, or string.
+
+  def parse_node str
+    case str
+    when nil, ANYVAL_MATCHER
+      ANY_VALUE
+
+    when RANGE_MATCHER
+      Range.new $1.to_i, $3.to_i, ($2 == "...")
+
+    when ILEN_MATCHER
+      Range.new $1.to_i, ($1.to_i + $2.to_i), true
+
+    when String
+      if @regex_opts || str =~ PATH_CHAR_MATCHER
+
+        # Remove extra suffix characters
+        str.gsub! %r{(^|[^#{Kronk::Path::RECH}])(\*+\?*)}, '\1*'
+        str.gsub! %r{(^|[^#{Kronk::Path::RECH}])\*+}, '\1*'
+
+        str = Regexp.escape str
+
+        # Remove escaping from special path characters
+        str.gsub! %r{#{Kronk::Path::RECH}([#{PATH_CHARS}])}, '\1'
+        str.gsub! %r{#{Kronk::Path::RECH}([#{RESC_CHARS}])}, '\1'
+        str.gsub! %r{(^|[^#{Kronk::Path::RECH}])([#{SUFF_CHARS}])},   '\1(.\2)'
+        str.gsub! %r{(^|[^\.#{Kronk::Path::RECH}])([#{SUFF_CHARS}])}, '\1(.\2)'
+
+        Regexp.new "\\A#{str}\\Z", @regex_opts
+
+      else
+        str.gsub %r{#{Kronk::Path::RECH}([^#{Kronk::Path::RECH}]|$)}, '\1'
+      end
+
+    else
+      str
+    end
+  end
+
+
+  ##
+  # Should this matcher try and find a match recursively.
+
+  def recursive?
+    @recursive
+  end
+end

data/lib/kronk/path/path_match.rb

@@ -0,0 +1,74 @@
+##
+# Represents a single match of a relative path against a data set.
+
+class Kronk::Path::PathMatch < Array
+
+  attr_accessor :matches
+
+  def initialize *args
+    @matches = []
+    super
+  end
+
+
+  def dup # :nodoc:
+    path_match = super
+    path_match.matches = @matches.dup
+    path_match
+  end
+
+
+  def append_match_for str, path # :nodoc:
+    match = @matches[str.to_i-1]
+    if match && !(String === match) && path[-1].empty?
+      path[-1] = match
+    else
+      path[-1] << match.to_s
+    end
+  end
+
+
+  ##
+  # Builds a path array by replacing %n values with matches.
+
+  def make_path path_map, regex_opts=nil, &block
+    path     = []
+    escape   = false
+    replace  = false
+    new_item = true
+    rindex   = ""
+
+    path_map.to_s.chars do |chr|
+      case chr
+      when Kronk::Path::ECH
+        escape = true
+
+      when Kronk::Path::DCH
+        new_item = true
+
+      when Kronk::Path::RCH
+        replace = true
+      end and next unless escape
+
+      if replace
+        if new_item && !rindex.empty? || chr.to_i.to_s != chr || escape
+          append_match_for(rindex, path) unless rindex.empty?
+          rindex  = ""
+          replace = false
+        else
+          rindex << chr
+        end
+      end
+
+      path      << ""  if new_item
+      path.last << chr unless replace
+
+      new_item = false
+      escape   = false
+    end
+
+    append_match_for(rindex, path) unless rindex.empty?
+
+    path
+  end
+end

data/lib/kronk/path/transaction.rb

@@ -41,10 +41,16 @@ class Kronk::Path::Transaction
   # operations on.
 
   def initialize data
-    @data    = data
-    @actions = Hash.new{|h,k| h[k] = []}
-
-    @make_array = []
+    @data     = data
+    @new_data = nil
+    @actions  = {
+      :select => [],
+      :delete => [],
+      :move   => {},
+      :map    => {}
+    }
+
+    @make_array = {}
   end
 
 
@@ -66,21 +72,26 @@ class Kronk::Path::Transaction
 
   def results opts={}
     new_data = transaction_select @data, *@actions[:select]
-    new_data = transaction_delete new_data, *@actions[:delete]
-    new_data = remake_arrays new_data, opts[:keep_indicies]
-    new_data
+    new_data = transaction_map    @data,  @actions[:map]
+    new_data = transaction_move   @data,  @actions[:move]
+    new_data = transaction_delete @data, *@actions[:delete]
+    remake_arrays new_data, opts[:keep_indicies]
   end
 
 
   def remake_arrays new_data, except_modified=false # :nodoc:
-    @make_array.each do |path_arr|
+    remake_paths = @make_array.keys.sort{|p1, p2| p2.length <=> p1.length}
+
+    remake_paths.each do |path_arr|
       key  = path_arr.last
       obj = Kronk::Path.data_at_path path_arr[0..-2], new_data
 
       next unless obj && Hash === obj[key]
-      next if except_modified &&
-        obj[key].length !=
-          Kronk::Path.data_at_path(path_arr, @data).length
+
+      if except_modified
+        data_at_path = Kronk::Path.data_at_path(path_arr, @data)
+        next if !data_at_path || obj[key].length != data_at_path.length
+      end
 
       obj[key] = hash_to_ary obj[key]
     end
@@ -94,70 +105,90 @@ class Kronk::Path::Transaction
 
 
   def transaction_select data, *data_paths # :nodoc:
-    data_paths = data_paths.compact
-    return data if data_paths.empty?
+    transaction data, data_paths, true do |new_curr_data, curr_data, key|
+      new_curr_data[key] = curr_data[key]
+    end
+  end
 
-    new_data = Hash.new
 
-    data_paths.each do |data_path|
-      Kronk::Path.find data_path, data do |obj, k, path|
+  def transaction_delete data, *data_paths # :nodoc:
+    transaction data, data_paths do |new_curr_data, curr_data, key|
+      new_curr_data.delete key
+    end
+  end
 
-        curr_data     = data
-        new_curr_data = new_data
 
-        path.each_with_index do |key, i|
-          if i == path.length - 1
-            new_curr_data[key] = curr_data[key]
+  def transaction_move data, match_target_hash # :nodoc:
+    return data if match_target_hash.empty?
+    path_val_hash = {}
 
-          else
-            new_curr_data[key] ||= Hash.new
+    match_target_hash.each do |data_path, path_map|
+      transaction data, [data_path] do |new_curr_data, cdata, key, path|
+        mapped_path = path.make_path path_map
+        path_val_hash[mapped_path] = new_curr_data.delete key
+        if @make_array[path]
+          @make_array.delete path
+          @make_array[mapped_path] = true
+        end
+      end
+    end
 
-            # Tag data item for conversion to Array.
-            # Hashes are used to conserve position of Array elements.
-            if Array === curr_data[key]
-              @make_array << path[0..i]
-            end
+    force_assign_paths @new_data, path_val_hash
+  end
 
-            new_curr_data = new_curr_data[key]
-            curr_data     = curr_data[key]
-          end
+
+  def transaction_map data, match_target_hash # :nodoc:
+    return data if match_target_hash.empty?
+    path_val_hash = {}
+
+    match_target_hash.each do |data_path, path_map|
+      Kronk::Path.find data_path, data do |sdata, key, spath|
+        mapped_path = spath.make_path path_map
+        path_val_hash[mapped_path] = sdata[key]
+        if @make_array[spath]
+          @make_array.delete spath
+          @make_array[mapped_path] = true
         end
       end
     end
 
-    new_data
+    force_assign_paths @new_data, path_val_hash
   end
 
 
-  def transaction_delete data, *data_paths # :nodoc:
+  def transaction data, data_paths, create_empty=false # :nodoc:
     data_paths = data_paths.compact
-    return data if data_paths.empty?
+    return @new_data || data if data_paths.empty?
 
-    new_data = data.dup
+    @new_data ||= create_empty ? Hash.new : data.dup
 
-    if Array === new_data
-      new_data = ary_to_hash new_data
+    if Array === @new_data
+      @new_data = ary_to_hash @new_data
     end
 
     data_paths.each do |data_path|
       Kronk::Path.find data_path, data do |obj, k, path|
-
         curr_data     = data
-        new_curr_data = new_data
+        new_curr_data = @new_data
 
         path.each_with_index do |key, i|
+          break unless new_curr_data
+
           if i == path.length - 1
-            new_curr_data.delete key
+            yield new_curr_data, curr_data, key, path if block_given?
 
           else
-            new_curr_data[key] = new_curr_data[key].dup if
-              new_curr_data[key] == curr_data[key]
+            if create_empty
+              new_curr_data[key] ||= Hash.new
 
-            if Array === new_curr_data[key]
-              new_curr_data[key] = ary_to_hash new_curr_data[key]
-              @make_array << path[0..i]
+            elsif new_curr_data[key] == curr_data[key]
+              new_curr_data[key] = Array === new_curr_data[key] ?
+                                    ary_to_hash(curr_data[key]) :
+                                    curr_data[key].dup
             end
 
+            @make_array[path[0..i]] = true if Array === curr_data[key]
+
             new_curr_data = new_curr_data[key]
             curr_data     = curr_data[key]
           end
@@ -165,7 +196,62 @@ class Kronk::Path::Transaction
       end
     end
 
-    new_data
+    @new_data
+  end
+
+
+  def force_assign_paths data, path_val_hash # :nodoc:
+    return data if path_val_hash.empty?
+    @new_data ||= (data.dup rescue [])
+
+    path_val_hash.each do |path, value|
+      curr_data     = data
+      new_curr_data = @new_data
+      prev_data     = nil
+      prev_key      = nil
+      prev_path     = []
+
+      path.each_with_index do |key, i|
+        if Array === new_curr_data
+          new_curr_data          = ary_to_hash new_curr_data
+          prev_data[prev_key]    = new_curr_data if prev_data
+          @new_data              = new_curr_data if i == 0
+          @make_array[prev_path] = true
+        end
+
+        last      = i == path.length - 1
+        prev_path = path[0..(i-1)] if i > 0
+        curr_path = path[0..i]
+        next_key  = path[i+1]
+
+        # new_curr_data is a hash from here on
+
+        @make_array.delete prev_path unless Integer === key
+
+        new_curr_data[key] = value and break if last
+
+        if ary_or_hash?(curr_data) && ary_or_hash?(curr_data[key])
+          new_curr_data[key] ||= curr_data[key]
+
+        elsif !ary_or_hash?(new_curr_data[key])
+          new_curr_data[key] = Integer === next_key ? [] : {}
+        end
+
+        @make_array[curr_path] = true if Array === new_curr_data[key]
+
+        prev_key      = key
+        prev_data     = new_curr_data
+        new_curr_data = new_curr_data[key]
+        curr_data     = ary_or_hash?(curr_data) ? curr_data[key] : nil
+      end
+    end
+
+    @new_data
+  end
+
+
+  def ary_or_hash? obj # :nodoc:
+    Array === obj || Hash === obj
   end
 
 
@@ -185,7 +271,8 @@ class Kronk::Path::Transaction
   # Clears the queued actions and cache.
 
   def clear
-    @actions.clear
+    @new_data = nil
+    @actions.each{|k,v| v.clear}
     @make_array.clear
   end
 
@@ -204,4 +291,27 @@ class Kronk::Path::Transaction
   def delete *paths
     @actions[:delete].concat paths
   end
+
+
+  ##
+  # Queues path moving for transaction. Moving a path will attempt to
+  # keep the original data structure and only affect the given paths.
+  # Empty hashes or arrays after a move are deleted.
+  #   t.move "my/path/1..4/key" => "new_path/%d/key",
+  #          "other/path/*"     => "moved/%d"
+
+  def move path_maps
+    @actions[:move].merge! path_maps
+  end
+
+
+  ##
+  # Queues path mapping for transaction. Mapping a path will only keep the
+  # mapped values, completely replacing the original data structure.
+  #   t.move "my/path/1..4/key" => "new_path/%d/key",
+  #          "other/path/*"     => "moved/%d"
+
+  def map path_maps
+    @actions[:map].merge! path_maps
+  end
 end