yerba 0.9.1-arm-linux-gnu → 0.10.0-arm-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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Yerba
+  # A parsed selector, split into its segments.
+  #
+  #   Yerba::Selector.parse("[3].talks[1]").segments  # => [3, "talks", 1]
+  #   Yerba::Selector.parse("[].speakers[]").segments # => [:all_items, "speakers", :all_items]
+  #   Yerba::Selector.parse("database.*").segments    # => ["database", :all_keys]
+  #   Yerba::Selector.parse(".title").relative?       # => true
+  #
+  # 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
+
+    def self.parse(selector)
+      return selector if selector.is_a?(Selector)
+
+      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)
+      end
+    end
+
+    # Builds a selector from segments: Strings (keys), Integers (indexes), `:all_items` or `:all_keys`.
+    #
+    #   Yerba::Selector.build([3, "talks", 1]).to_s # => "[3].talks[1]"
+    #
+    def self.build(segments, relative: false)
+      new(segments, relative: relative)
+    end
+
+    def self.clear_cache!
+      @cache = nil
+    end
+
+    def self.cache
+      @cache ||= {}
+    end
+    private_class_method :cache
+
+    def self.decode(segment)
+      case segment
+      when Hash
+        segment["all"] == "keys" ? ALL_KEYS : ALL_ITEMS
+      else
+        segment
+      end
+    end
+    private_class_method :decode
+
+    def initialize(segments, relative: false, source: nil)
+      @segments = segments.dup.freeze
+      @relative = relative
+      @source = source
+
+      freeze
+    end
+
+    def relative?
+      @relative
+    end
+
+    def absolute?
+      !@relative
+    end
+
+    def empty?
+      segments.empty?
+    end
+
+    def wildcard?
+      segments.any? { |segment| [ALL_ITEMS, ALL_KEYS].include?(segment) }
+    end
+
+    # "[3].talks[1]" => "[3].talks"
+    def parent
+      self.class.build(segments[0...-1], relative: relative?)
+    end
+
+    # Selector.parse("[3]").join("talks", 1) => "[3].talks[1]"
+    def join(*more)
+      self.class.build(segments + more, relative: relative?)
+    end
+
+    def dig(values)
+      raise ArgumentError, "Cannot dig a wildcard selector (#{self}), use Document#find or Collection.find instead" if wildcard?
+
+      segments.reduce(values) do |current, segment|
+        case current
+        when Array
+          segment.is_a?(Integer) ? current[segment] : nil
+        when Hash
+          segment.is_a?(Integer) ? nil : current[segment]
+        end
+      end
+    end
+
+    def to_s
+      @source || self.class.send(:native_build, JSON.generate(encoded_segments), relative?)
+    end
+    alias to_str to_s
+
+    def ==(other)
+      other.is_a?(Selector) && other.segments == segments && other.relative? == relative?
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, segments, relative?].hash
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_s.inspect} #{segments.inspect}>"
+    end
+
+    private
+
+    def encoded_segments
+      segments.map do |segment|
+        case segment
+        when ALL_ITEMS
+          { all: "items" }
+        when ALL_KEYS
+          { all: "keys" }
+        else
+          segment
+        end
+      end
+    end
+  end
+end