yerba 0.9.2-aarch64-linux-gnu → 0.10.0-aarch64-linux-gnu

data/lib/yerba/collection.rb

@@ -12,12 +12,12 @@ module Yerba
       Dir.glob(@glob).each { |path| yield Document.new(path) }
     end
 
-    def get(path)
-      self.class.get(@glob, path)
+    def get(selector)
+      self.class.get(@glob, selector)
     end
 
-    def find(path, condition: nil, select: nil)
-      self.class.find(@glob, path, condition: condition, select: select)
+    def find(selector, condition: nil, select: nil)
+      self.class.find(@glob, selector, condition: condition, select: select)
     end
 
     def find_by(...)

data/lib/yerba/document.rb

@@ -2,6 +2,8 @@
 
 module Yerba
   class Document
+    include NodeTree
+
     ROOT_SELECTOR = ""
 
     def self.cache
@@ -76,6 +78,48 @@ module Yerba
       File.mtime(@path) != @loaded_mtime
     end
 
+    def [](selector)
+      return native_node_at(selector) unless selector.is_a?(String)
+
+      parsed = Selector.parse(selector)
+      matches = find_nodes(parsed)
+      return native_node_at(selector) if matches.nil?
+
+      matches = matches.map { |match| match&.dup }
+      parsed.wildcard? ? matches.compact : matches.first
+    end
+    alias node_at []
+
+    def value_at(selector)
+      return native_value_at(selector) unless selector.is_a?(String) || selector.is_a?(Selector)
+
+      parsed = Selector.parse(selector)
+      matches = find_nodes(parsed) unless parsed.wildcard?
+      return native_value_at(selector) if matches.nil?
+
+      node = matches.first
+      return nil if node.nil?
+
+      node.is_a?(Scalar) && node.tree_node? ? node.value : native_value_at(selector)
+    end
+
+    def nodes
+      generation = native_generation
+      return @nodes if @nodes_generation == generation
+
+      @nodes_generation = generation
+      @nodes = build_nodes(native_node_records)
+    end
+
+    def length_at(selector)
+      parsed = Selector.parse(selector)
+      matches = find_nodes(parsed) unless parsed.wildcard?
+      return Array(value_at(selector)).length if matches.nil?
+
+      children = matches.first&.tree_children
+      children.is_a?(Array) ? children.length : 0
+    end
+
     def dig(*keys)
       keys.reduce(self) { |node, key| node.nil? ? nil : node[key] }
     end
@@ -177,6 +221,96 @@ module Yerba
 
     private
 
+    def build_nodes(records)
+      built = []
+
+      records.each do |parent, type, selector, key_name, value, has_value, location, key_location|
+        key = Scalar.from_document(nil, nil, key_location, nil, value: key_name) if key_name
+        node = build_node(type, selector, location, key, value)
+
+        node.attach_tree(built.first || node, tree_container(type), !has_value) if type
+        add_child(built[parent], key_name, node) unless parent.negative?
+
+        built << node
+      end
+
+      built.each { |node| node&.tree_children&.freeze }
+      built.first
+    end
+
+    def build_node(type, selector, location, key, value)
+      case type
+      when :scalar
+        Scalar.from_document(self, selector, location, key, value: value)
+      when :map
+        Map.from_document(self, selector, location, key)
+      when :sequence
+        Sequence.from_document(self, selector, location, key)
+      else
+        native_node_at(selector)
+      end
+    end
+
+    def tree_container(type)
+      case type
+      when :map
+        {}
+      when :sequence
+        []
+      end
+    end
+
+    def add_child(parent, key_name, node)
+      children = parent.tree_children
+
+      if children.is_a?(Hash)
+        children[key_name] = node
+      else
+        children << node
+      end
+    end
+
+    def find_nodes(selector)
+      return nil if selector.relative? || malformed?(selector.to_s) || nodes.nil?
+
+      wildcard = selector.wildcard?
+
+      selector.segments.reduce([nodes]) do |current, segment|
+        current.flat_map do |node|
+          children = node&.tree_node? ? node.tree_children : nil
+          matches = children && child_matches(children, segment)
+          return nil if matches.nil?
+
+          wildcard && children.is_a?(Hash) ? matches.reject { |match| valueless_entry?(match) } : matches
+        end
+      end
+    end
+
+    def valueless_entry?(node)
+      node.valueless?
+    end
+
+    def malformed?(selector)
+      selector.end_with?(".") || selector.include?("..") || (selector.include?("[") && !selector.include?("]"))
+    end
+
+    def child_matches(children, segment)
+      case segment
+      when Selector::ALL_ITEMS
+        children if children.is_a?(Array)
+      when Selector::ALL_KEYS
+        children.values if children.is_a?(Hash)
+      when Integer
+        return nil unless children.is_a?(Array)
+
+        segment < children.length ? [children[segment]] : []
+      else
+        return nil unless children.is_a?(Hash)
+
+        children.key?(segment) ? [children[segment]] : []
+      end
+    end
+
     def empty_root?
       root.is_a?(Scalar) && root.value.nil?
     end

data/lib/yerba/formatting.rb

@@ -23,6 +23,7 @@ module Yerba
       when true then "true"
       when false then "false"
       when nil then "null"
+      when String then Yerba.quote_scalar(value, "flow")
       else value.to_s
       end
     end

data/lib/yerba/location.rb

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
 
 module Yerba
-  Location = Data.define(:start_line, :start_column, :end_line, :end_column, :start_offset, :end_offset)
+  Location = Data.define(
+    :start_line, :start_column, :end_line, :end_column, :start_offset, :end_offset,
+    :start_character_column, :end_character_column
+  ) do
+    def initialize(start_column:, end_column:, start_character_column: start_column, end_character_column: end_column, **)
+      super
+    end
+  end
 end

data/lib/yerba/map.rb

@@ -40,13 +40,14 @@ module Yerba
           all_keys = keys
           key_index = all_keys.index(key.to_s)
           after_key = key_index&.positive? ? all_keys[key_index - 1] : nil
+          before_key = key_index&.zero? ? all_keys[1] : nil
 
-          document.delete(new_path)
-
-          if after_key
-            document.insert(new_path, coerced, after: after_key, plain: true)
+          if after_key || before_key
+            document.delete(new_path)
+            document.insert(new_path, coerced, after: after_key, before: before_key, plain: true)
           else
-            document.insert(new_path, coerced, plain: true)
+            document.set(new_path, coerce_value(value, style: :flow), plain: true)
+            document[new_path].collection_style = :block unless value.empty?
           end
         elsif document.exists?(new_path)
           document.set(new_path, coerced, plain: is_collection)
@@ -93,6 +94,12 @@ module Yerba
         return self
       end
 
+      if (tree = current_children)
+        tree.each_key { |name| yield name, tree[name]&.dup }
+
+        return self
+      end
+
       names = keys
       values = document.get_all(@selector.empty? ? "*" : "#{@selector}.*")
 
@@ -124,6 +131,9 @@ module Yerba
 
     def value_at(key)
       if connected?
+        child = current_children&.[](key.to_s)
+        return child.value if child.is_a?(Scalar)
+
         new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
         document.value_at(new_path)
       else
@@ -135,7 +145,7 @@ module Yerba
     #
     # When +key+ is given and the map is connected to a document, deletes that key
     # from the map in the YAML document. When no +key+ is given and the map is
-    # connected, removes the entire map node at its selector path. When not connected
+    # connected, removes the entire map node at its selector. When not connected
     # to a document, delegates to the underlying Hash.
     #
     # Returns +self+.

data/lib/yerba/node.rb

@@ -1,7 +1,31 @@
 # frozen_string_literal: true
 
 module Yerba
+  module NodeTree
+    protected
+
+    def tree_node?
+      !@tree.nil? && @tree.equal?(document.nodes)
+    end
+
+    def tree_children
+      @children
+    end
+
+    def valueless?
+      @valueless == true
+    end
+
+    def attach_tree(tree, children, valueless)
+      @tree = tree
+      @children = children
+      @valueless = valueless
+    end
+  end
+
   module Node
+    include NodeTree
+
     attr_reader :selector, :location, :key
 
     def file_path
@@ -26,6 +50,17 @@ module Yerba
       document.source(@selector)
     end
 
+    def children
+      tree = current_children
+
+      case tree
+      when Hash
+        tree.transform_values { |child| child&.dup }
+      when Array
+        tree.map { |child| child&.dup }
+      end
+    end
+
     module ClassMethods
       def from_document(document, selector, location = nil, key = nil, **attributes)
         instance = allocate
@@ -58,6 +93,12 @@ module Yerba
 
     private
 
+    def current_children
+      node = tree_node? ? self : document&.[](@selector)
+
+      node.tree_children if node.is_a?(Node) && node.tree_node?
+    end
+
     def init_node(document, selector, location, key, file_path, line)
       @document = document
       @selector = selector

data/lib/yerba/query_result.rb

@@ -4,47 +4,70 @@ module Yerba
   class QueryResult
     include Enumerable
 
-    def initialize(sequence, indices)
+    def initialize(sequence, indices, &query)
       @sequence = sequence
       @indices = indices
+      @query = query
+      @tree = current_tree
     end
 
     def each
       return enum_for(:each) unless block_given?
 
-      @indices.each { |index| yield @sequence[index] }
+      current_indices.each { |index| yield @sequence[index] }
     end
 
     def [](position)
-      index = @indices[position]
+      index = current_indices[position]
 
       @sequence[index] if index
     end
 
-    def first
-      self[0]
+    def first(count = nil)
+      return self[0] if count.nil?
+
+      current_indices.first(count).map { |index| @sequence[index] }
     end
 
-    def last
-      self[-1]
+    def last(count = nil)
+      return self[-1] if count.nil?
+
+      current_indices.last(count).map { |index| @sequence[index] }
     end
 
     def length
-      @indices.length
+      current_indices.length
     end
     alias size length
     alias count length
 
     def empty?
-      @indices.empty?
+      current_indices.empty?
     end
 
     def indices
-      @indices.dup
+      current_indices.dup
     end
 
     def inspect
       "#<Yerba::QueryResult length=#{length}>"
     end
+
+    private
+
+    def current_indices
+      tree = current_tree
+
+      if @query && !tree.equal?(@tree)
+        @indices = @query.call
+        @tree = tree
+      end
+
+      @indices
+    end
+
+    def current_tree
+      @sequence&.document&.nodes
+    end
   end
 end

data/lib/yerba/scalar.rb

@@ -12,6 +12,11 @@ module Yerba
     end
 
     def value
+      live = live_document if @selector
+      adopt_current_node(live) if live && !tree_node?
+
+      return @value.is_a?(String) ? @value.dup : @value if tree_node?
+
       @value ||= document&.value_at(@selector)
     end
 
@@ -72,8 +77,32 @@ module Yerba
       end
     end
 
+    protected
+
+    def stored_value
+      @value
+    end
+
     private
 
+    def live_document
+      return @document if @document
+
+      document if @file_path && Document.cache.key?(@file_path)
+    end
+
+    def adopt_current_node(live)
+      node = live[@selector]
+
+      if node.is_a?(Scalar) && node.tree_node?
+        @value = node.stored_value
+        attach_tree(live.nodes, nil, node.valueless?)
+      else
+        @value = nil
+        @tree = nil
+      end
+    end
+
     def init_from(value: nil, quote_style: nil, **)
       @value = value
       @quote_style = quote_style

data/lib/yerba/selector.rb

@@ -10,11 +10,12 @@ module Yerba
   #   Yerba::Selector.parse("database.*").segments    # => ["database", :all_keys]
   #   Yerba::Selector.parse(".title").relative?       # => true
   #
-  # Keys are Strings, indexes Integers, `[]` is `:all_items` and `*` is `:all_keys`.
+  # Keys are Strings, indexes Integers (negative from the end), `[]` is `:all_items` and `*` is `:all_keys`.
   #
   class Selector
     ALL_KEYS = :all_keys
     ALL_ITEMS = :all_items
+    CACHE_LIMIT = 10_000
 
     attr_reader :segments
 
@@ -24,6 +25,7 @@ module Yerba
       string = selector.to_s
 
       cache[string] ||= begin
+        cache.clear if cache.size >= CACHE_LIMIT
         parsed = native_parse(string)
 
         new(parsed["segments"].map { |segment| decode(segment) }, relative: parsed["relative"], source: string)

data/lib/yerba/sequence.rb

@@ -45,6 +45,9 @@ module Yerba
 
     def value_at(index)
       if connected?
+        child = current_children&.[](index) if index.is_a?(Integer) && !index.negative?
+        return child.value if child.is_a?(Scalar)
+
         new_path = "#{@selector}[#{index}]"
         document.value_at(new_path)
       else
@@ -73,15 +76,15 @@ module Yerba
 
     def concat(items)
       if connected?
-        hashes = items.map do |item|
+        values = items.map do |item|
           case item
           when Map then item.to_hash
-          when Hash then item
-          else { value: item.to_s }
+          when Scalar then item.value
+          else item
           end
         end
 
-        document.insert_objects(@selector, hashes)
+        document.insert_objects(@selector, values)
       else
         @data.concat(items)
       end
@@ -92,6 +95,12 @@ module Yerba
     def each(&)
       return enum_for(:each) unless block_given?
 
+      if connected? && (tree = current_children)
+        tree.each { |child| yield child&.dup }
+
+        return self
+      end
+
       if connected?
         items = document.get_all("#{@selector}[]")
 
@@ -114,7 +123,7 @@ module Yerba
     end
 
     def where(selector = nil, value = nil, **criteria)
-      QueryResult.new(self, indices_of(selector, value, **criteria))
+      QueryResult.new(self, indices_of(selector, value, **criteria)) { indices_of(selector, value, **criteria) }
     end
 
     def pluck(*fields)
@@ -211,28 +220,24 @@ module Yerba
     end
 
     def length
-      if connected?
-        scalar_items = document.value_at("#{@selector}[]")
+      return @data.length unless connected?
 
-        if scalar_items.is_a?(Array) && !scalar_items.empty?
-          scalar_items.length
-        else
-          data = document.value_at(@selector)
-
-          data.is_a?(Array) ? data.length : 0
-        end
-      else
-        @data.length
-      end
+      current_children&.size || document.length_at(@selector)
     end
     alias size length
 
-    def first
-      self[0]
+    def first(count = nil)
+      return self[0] if count.nil?
+
+      super
     end
 
-    def last
-      self[length - 1] # rubocop:disable Style/NegativeArrayIndex
+    def last(count = nil)
+      size = length
+      return self[size - 1] if count.nil?
+      raise ArgumentError, "negative array size" if count.negative?
+
+      ([size - count, 0].max...size).map { |index| self[index] }
     end
 
     def remove(value)
@@ -263,15 +268,15 @@ module Yerba
       self
     end
 
-    def sort(by: nil, case_sensitive: false)
-      document&.sort(@selector, by: by, case_sensitive: case_sensitive)
+    def sort(by: nil, order: nil, case_sensitive: false)
+      document&.sort(@selector, by: by, order: order, case_sensitive: case_sensitive)
 
       self
     end
 
     # Deletes the entire sequence node from the YAML document.
     #
-    # Removes the sequence at its selector path from the parent document.
+    # Removes the sequence at its selector from the parent document.
     # Has no effect if the sequence is not connected to a document.
     #
     # Returns the document, or +nil+ if the sequence is not connected to a document.
@@ -345,8 +350,8 @@ module Yerba
 
     private
 
-    def dig_into(hash, path)
-      keys = path.split(".")
+    def dig_into(hash, selector)
+      keys = selector.split(".")
 
       keys.reduce(hash) { |current, key| current.is_a?(Hash) ? current[key] : nil }
     end
@@ -356,8 +361,8 @@ module Yerba
 
       criteria.each do |field, value|
         if value.is_a?(Hash)
-          flatten_hash("#{field}[]", value).each do |path, leaf_value|
-            expanded << [path, leaf_value]
+          flatten_hash("#{field}[]", value).each do |selector, leaf_value|
+            expanded << [selector, leaf_value]
           end
         elsif value.is_a?(Array)
           value.each do |item|
@@ -375,12 +380,12 @@ module Yerba
       result = {}
 
       hash.each do |key, value|
-        path = "#{prefix}.#{key}"
+        selector = "#{prefix}.#{key}"
 
         if value.is_a?(Hash)
-          flatten_hash("#{path}[]", value).each { |nested_path, leaf| result[nested_path] = leaf }
+          flatten_hash("#{selector}[]", value).each { |nested_selector, leaf| result[nested_selector] = leaf }
         else
-          result[path] = value
+          result[selector] = value
         end
       end
 
@@ -399,8 +404,8 @@ module Yerba
       end
     end
 
-    def dig_values(hash, path)
-      parts = path.split(".")
+    def dig_values(hash, selector)
+      parts = selector.split(".")
       current = [hash]
 
       parts.each do |part|

data/lib/yerba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yerba
-  VERSION = "0.9.2"
+  VERSION = "0.10.0"
 end

data/rust/Cargo.lock

@@ -1431,7 +1431,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.9.2"
+version = "0.10.0"
 dependencies = [
  "anstyle-query",
  "cbindgen",

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.9.2"
+version = "0.10.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"