yerba 0.3.0-aarch64-linux-gnu → 0.4.1-aarch64-linux-gnu

data/lib/yerba/document.rb

@@ -2,8 +2,10 @@
 
 module Yerba
   class Document
+    ROOT_SELECTOR = ""
+
     def root
-      self[""]
+      self[ROOT_SELECTOR]
     end
 
     def map?
@@ -15,11 +17,11 @@ module Yerba
     end
 
     def to_h
-      get_value("")
+      get_value(ROOT_SELECTOR)
     end
 
     def to_a
-      get_value("")
+      get_value(ROOT_SELECTOR)
     end
 
     def to_yaml
@@ -48,6 +50,46 @@ module Yerba
       end
     end
 
+    def find_by(...)
+      root.find_by(...)
+    end
+
+    def where(...)
+      root.where(...)
+    end
+
+    def pluck(...)
+      root.pluck(...)
+    end
+
+    def <<(item)
+      root << item
+    end
+
+    def concat(items)
+      root.concat(items)
+    end
+
+    def save!(apply: false)
+      Yerbafile.apply!(self, apply) if apply
+      write!
+
+      self
+    end
+
+    def apply!(yerbafile = nil)
+      apply(yerbafile)
+      write! if changed?
+
+      self
+    end
+
+    def apply(yerbafile = nil)
+      Yerbafile.apply!(self, yerbafile)
+
+      self
+    end
+
     def inspect
       if path
         "#<Yerba::Document path=#{path.inspect}>"

data/lib/yerba/query_result.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Yerba
+  class QueryResult
+    include Enumerable
+
+    def initialize(sequence, indices)
+      @sequence = sequence
+      @indices = indices
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @indices.each { |index| yield @sequence[index] }
+    end
+
+    def [](position)
+      index = @indices[position]
+
+      @sequence[index] if index
+    end
+
+    def first
+      self[0]
+    end
+
+    def last
+      self[-1]
+    end
+
+    def length
+      @indices.length
+    end
+    alias size length
+    alias count length
+
+    def empty?
+      @indices.empty?
+    end
+
+    def indices
+      @indices.dup
+    end
+
+    def inspect
+      "#<Yerba::QueryResult length=#{length}>"
+    end
+  end
+end

data/lib/yerba/sequence.rb

@@ -55,10 +55,121 @@ module Yerba
       self
     end
 
+    def concat(items)
+      if @document
+        hashes = items.map do |item|
+          case item
+          when Map then item.to_hash
+          when Hash then item
+          else { value: item.to_s }
+          end
+        end
+
+        @document.insert_objects(@selector, hashes)
+      else
+        @data.concat(items)
+      end
+
+      self
+    end
+
     def each
       return enum_for(:each) unless block_given?
 
-      length.times { |i| yield self[i] }
+      length.times { |index| yield self[index] }
+    end
+
+    def find_by(selector = nil, value = nil, **criteria)
+      index = index_of(selector, value, **criteria)
+
+      self[index] if index
+    end
+
+    def where(selector = nil, value = nil, **criteria)
+      QueryResult.new(self, indices_of(selector, value, **criteria))
+    end
+
+    def pluck(*fields)
+      return [] unless @document
+
+      all_values = @document.get_value(@selector)
+      return [] unless all_values.is_a?(Array)
+
+      if fields.length == 1
+
+        all_values.map { |item| item.is_a?(Hash) ? item[fields.first.to_s] : item }
+      else
+
+        all_values.map { |item| fields.map(&:to_s).map { |field| item.is_a?(Hash) ? item[field] : nil } }
+      end
+    end
+
+    def index_of(selector = nil, value = nil, **criteria)
+      if selector && value.nil? && criteria.empty?
+        values = @document&.get("#{@selector}[]")
+
+        return values.index(selector) if values.is_a?(Array)
+
+        return nil
+      end
+
+      criteria[selector] = value if selector && value
+      pairs = expand_nested_criteria(criteria)
+
+      indices = nil
+
+      pairs.each do |field, expected|
+        field_string = field.to_s
+
+        if field_string.include?("[]")
+          matching = nested_indices_for(field_string, expected)
+        else
+          values = @document&.get("#{@selector}[].#{field_string}")
+
+          next unless values.is_a?(Array)
+
+          matching = values.each_with_index.filter_map { |actual, index| index if actual == expected }
+        end
+
+        indices = indices ? indices & matching : matching
+      end
+
+      indices&.first
+    end
+
+    def indices_of(selector = nil, value = nil, **criteria)
+      if selector && value.nil? && criteria.empty?
+        values = @document&.get("#{@selector}[]")
+
+        if values.is_a?(Array)
+          return values.each_with_index.filter_map { |actual, index| index if actual == selector }
+        end
+
+        return []
+      end
+
+      criteria[selector] = value if selector && value
+      pairs = expand_nested_criteria(criteria)
+
+      indices = nil
+
+      pairs.each do |field, expected|
+        field_string = field.to_s
+
+        if field_string.include?("[]")
+          matching = nested_indices_for(field_string, expected)
+        else
+          values = @document&.get("#{@selector}[].#{field_string}")
+
+          next unless values.is_a?(Array)
+
+          matching = values.each_with_index.filter_map { |actual, index| index if actual == expected }
+        end
+
+        indices = indices ? indices & matching : matching
+      end
+
+      indices || []
     end
 
     def length
@@ -69,6 +180,7 @@ module Yerba
           scalar_items.length
         else
           data = @document.get_value(@selector)
+
           data.is_a?(Array) ? data.length : 0
         end
       else
@@ -156,6 +268,79 @@ module Yerba
 
     private
 
+    def expand_nested_criteria(criteria)
+      expanded = []
+
+      criteria.each do |field, value|
+        if value.is_a?(Hash)
+          flatten_hash("#{field}[]", value).each do |path, leaf_value|
+            expanded << [path, leaf_value]
+          end
+        elsif value.is_a?(Array)
+          value.each do |item|
+            expanded << ["#{field}[]", item]
+          end
+        else
+          expanded << [field, value]
+        end
+      end
+
+      expanded
+    end
+
+    def flatten_hash(prefix, hash)
+      result = {}
+
+      hash.each do |key, value|
+        path = "#{prefix}.#{key}"
+
+        if value.is_a?(Hash)
+          flatten_hash("#{path}[]", value).each { |nested_path, leaf| result[nested_path] = leaf }
+        else
+          result[path] = value
+        end
+      end
+
+      result
+    end
+
+    def nested_indices_for(field, expected)
+      all_values = @document&.get_value(@selector)
+      return [] unless all_values.is_a?(Array)
+
+      all_values.each_with_index.filter_map do |item, index|
+        next unless item.is_a?(Hash)
+
+        nested_values = dig_values(item, field)
+        index if nested_values.include?(expected)
+      end
+    end
+
+    def dig_values(hash, path)
+      parts = path.split(".")
+      current = [hash]
+
+      parts.each do |part|
+        next_values = []
+
+        current.each do |value|
+          if part == "[]" && value.is_a?(Array)
+            next_values.concat(value)
+          elsif part.end_with?("[]")
+            key = part.chomp("[]")
+            child = value.is_a?(Hash) ? value[key] : nil
+            next_values.concat(child) if child.is_a?(Array)
+          elsif value.is_a?(Hash)
+            next_values << value[part] if value.key?(part)
+          end
+        end
+
+        current = next_values
+      end
+
+      current
+    end
+
     def format_for_insert(value)
       Formatting.quote(value, detect_quote_style)
     end
@@ -172,6 +357,7 @@ module Yerba
           result
         else
           data = @document.get_value(@selector)
+
           data.is_a?(Array) ? data : []
         end
       else

data/lib/yerba/version.rb

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

data/lib/yerba/yerbafile.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Yerba
+  class Yerbafile
+    attr_reader :path
+
+    def initialize(path)
+      @path = File.expand_path(path)
+
+      raise Yerba::Error, "Yerbafile not found: #{path}" unless File.exist?(@path)
+    end
+
+    def self.find(directory = Dir.pwd)
+      path = locate(directory)
+
+      path ? new(path) : nil
+    end
+
+    def self.find!(directory = Dir.pwd)
+      find(directory) || raise(Yerba::Error, "No Yerbafile found")
+    end
+
+    def self.resolve(yerbafile = nil)
+      case yerbafile
+      when Yerbafile then yerbafile
+      when String then new(yerbafile)
+      when true, nil then find!
+      end
+    end
+
+    def self.apply!(document, yerbafile = nil)
+      resolve(yerbafile).apply(document)
+    end
+
+    def apply(document)
+      document.apply_yerbafile(@path)
+
+      document
+    end
+
+    def inspect
+      "#<Yerba::Yerbafile path=#{@path.inspect}>"
+    end
+  end
+end

data/lib/yerba.rb

@@ -8,8 +8,10 @@ require_relative "yerba/formatting"
 require_relative "yerba/scalar"
 require_relative "yerba/map"
 require_relative "yerba/sequence"
+require_relative "yerba/query_result"
 require_relative "yerba/document"
 require_relative "yerba/collection"
+require_relative "yerba/yerbafile"
 
 begin
   major, minor, = RUBY_VERSION.split(".")

data/rust/Cargo.lock

@@ -472,6 +472,7 @@ version = "1.0.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
 dependencies = [
+ "indexmap",
  "itoa",
  "memchr",
  "serde",
@@ -784,7 +785,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.3.0"
+version = "0.4.1"
 dependencies = [
  "cbindgen",
  "clap",
@@ -795,6 +796,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_yaml",
+ "tempfile",
  "yaml_parser",
 ]
 

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.3.0"
+version = "0.4.1"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"
@@ -25,7 +25,7 @@ rowan = "0.16"
 glob = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.9"
-serde_json = "1"
+serde_json = { version = "1", features = ["preserve_order"] }
 clap = { version = "4", features = ["derive"] }
 indoc = "2"
 rayon = "1"
@@ -34,3 +34,4 @@ rayon = "1"
 cbindgen = "0.28"
 
 [dev-dependencies]
+tempfile = "3"

data/rust/cbindgen.toml

@@ -9,6 +9,7 @@ no_includes = true
 
 [export]
 include = [
+  "NodeType",
   "YerbaValueType",
   "YerbaResult",
   "YerbaTypedValue",

data/rust/rustfmt.toml

@@ -1,2 +1,2 @@
 tab_spaces = 2
-max_width = 120
+max_width = 160

data/rust/src/commands/apply.rs

@@ -1,5 +1,14 @@
 use super::run_yerbafile;
 
-pub fn run() {
-  run_yerbafile(true);
+#[derive(clap::Args)]
+#[command(about = "Apply Yerbafile rules to all matching files (or specific files)")]
+pub struct Args {
+  /// Specific files to apply rules to (applies to all if omitted)
+  files: Vec<String>,
+}
+
+impl Args {
+  pub fn run(self) {
+    run_yerbafile(true, self.files);
+  }
 }

data/rust/src/commands/blank_lines.rs

@@ -39,10 +39,7 @@ impl Args {
     } else {
       use super::color::*;
 
-      eprintln!(
-        "{RED}Error:{RESET} expected a number for blank line count, got '{}'",
-        self.first
-      );
+      eprintln!("{RED}Error:{RESET} expected a number for blank line count, got '{}'", self.first);
 
       std::process::exit(1);
     };

data/rust/src/commands/check.rs

@@ -1,5 +1,14 @@
 use super::run_yerbafile;
 
-pub fn run() {
-  run_yerbafile(false);
+#[derive(clap::Args)]
+#[command(about = "Check if files match Yerbafile rules (exits 1 if changes needed)")]
+pub struct Args {
+  /// Specific files to check (checks all if omitted)
+  files: Vec<String>,
+}
+
+impl Args {
+  pub fn run(self) {
+    run_yerbafile(false, self.files);
+  }
 }

data/rust/src/commands/directives.rs

@@ -0,0 +1,61 @@
+use std::sync::LazyLock;
+
+use indoc::indoc;
+
+use super::colorize_examples;
+use super::{output, parse_file, resolve_files};
+
+static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
+  colorize_examples(indoc! {r#"
+    yerba directives config.yml --ensure
+    yerba directives config.yml --remove
+    yerba directives "data/**/*.yml" --ensure
+    yerba directives config.yml --ensure --dry-run
+  "#})
+});
+
+#[derive(clap::Args)]
+#[command(
+  about = "Add or remove the document start marker (---)",
+  arg_required_else_help = true,
+  after_help = EXAMPLES.as_str()
+)]
+pub struct Args {
+  file: String,
+  /// Add --- if missing
+  #[arg(long)]
+  ensure: bool,
+  /// Remove --- if present
+  #[arg(long)]
+  remove: bool,
+  #[arg(long)]
+  dry_run: bool,
+}
+
+impl Args {
+  pub fn run(self) {
+    if !self.ensure && !self.remove {
+      use super::color::*;
+      eprintln!("{RED}Error:{RESET} specify --ensure or --remove");
+      std::process::exit(1);
+    }
+
+    if self.ensure && self.remove {
+      use super::color::*;
+      eprintln!("{RED}Error:{RESET} --ensure and --remove are mutually exclusive");
+      std::process::exit(1);
+    }
+
+    for resolved_file in resolve_files(&self.file) {
+      let mut document = parse_file(&resolved_file);
+
+      if self.ensure {
+        let _ = document.ensure_directives();
+      } else if self.remove {
+        let _ = document.remove_directives();
+      }
+
+      output(&resolved_file, &document, self.dry_run);
+    }
+  }
+}

data/rust/src/commands/get.rs

@@ -77,10 +77,7 @@ impl Args {
 
         use super::color::*;
 
-        eprintln!(
-          "{RED}Error:{RESET} selector \"{}\" not found in {}",
-          self.selector, resolved_file
-        );
+        eprintln!("{RED}Error:{RESET} selector \"{}\" not found in {}", self.selector, resolved_file);
 
         show_similar_selectors(resolved_file, &document, &self.selector);
         process::exit(1);
@@ -97,11 +94,7 @@ impl Args {
 
           if !document.exists(&full_selector) {
             use super::color::*;
-            eprintln!(
-              "{RED}Error:{RESET} select field \"{}\" not found in {}",
-              field.trim(),
-              resolved_file
-            );
+            eprintln!("{RED}Error:{RESET} select field \"{}\" not found in {}", field.trim(), resolved_file);
             show_similar_selectors(resolved_file, &document, &full_selector);
             process::exit(1);
           }
@@ -175,23 +168,13 @@ impl Args {
         }
       }
     } else if all_results.len() == 1 {
-      println!(
-        "{}",
-        serde_json::to_string_pretty(&all_results[0]).unwrap_or_else(|_| "null".to_string())
-      );
+      println!("{}", serde_json::to_string_pretty(&all_results[0]).unwrap_or_else(|_| "null".to_string()));
     } else {
-      println!(
-        "{}",
-        serde_json::to_string_pretty(&all_results).unwrap_or_else(|_| "[]".to_string())
-      );
+      println!("{}", serde_json::to_string_pretty(&all_results).unwrap_or_else(|_| "[]".to_string()));
     }
   }
 
-  fn resolve_search_scope(
-    &self,
-    selector: &yerba::Selector,
-    condition_path: Option<&yerba::Selector>,
-  ) -> (yerba::Selector, Option<yerba::Selector>) {
+  fn resolve_search_scope(&self, selector: &yerba::Selector, condition_path: Option<&yerba::Selector>) -> (yerba::Selector, Option<yerba::Selector>) {
     if let Some(condition) = condition_path {
       if condition.is_relative() {
         let (container, field) = selector.split_at_last_bracket();