yerba 0.2.0-arm-linux-gnu

data/lib/yerba/collection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Yerba
+  class Collection
+    include Enumerable
+
+    def initialize(glob)
+      @glob = glob
+    end
+
+    def each
+      Dir.glob(@glob).each { |path| yield Document.new(path) }
+    end
+
+    def get(path)
+      self.class.get(@glob, path)
+    end
+
+    def find(path, condition: nil, select: nil)
+      self.class.find(@glob, path, condition: condition, select: select)
+    end
+
+    def apply!
+      each do |document|
+        yield document
+
+        document.save!
+      end
+    end
+  end
+end

data/lib/yerba/document.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Yerba
+  class Document
+    def root
+      self[""]
+    end
+
+    def map?
+      root.is_a?(Map)
+    end
+
+    def sequence?
+      root.is_a?(Sequence)
+    end
+
+    def to_h
+      get_value("")
+    end
+
+    def to_a
+      get_value("")
+    end
+
+    def to_yaml
+      to_s
+    end
+
+    def dig(*keys)
+      result = keys.reduce(self) { |node, key| node.nil? ? nil : node[key] }
+
+      result&.value
+    end
+
+    def at_path(path)
+      if path.include?("[]")
+        values = get(path)
+        return [] unless values.is_a?(Array)
+
+        path.sub("[]", "")
+
+        values.each_with_index.map do |_value, index|
+          resolved_path = path.sub("[]", "[#{index}]")
+          self[resolved_path]
+        end
+      else
+        self[path]
+      end
+    end
+
+    def inspect
+      if path
+        "#<Yerba::Document path=#{path.inspect}>"
+      else
+        "#<Yerba::Document (parsed)>"
+      end
+    end
+  end
+end

data/lib/yerba/formatting.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Yerba
+  module Formatting
+    def self.quote(value, style)
+      case style
+      when :double
+        escaped = value.to_s.gsub("\\", "\\\\").gsub('"', '\\"')
+        "\"#{escaped}\""
+      when :single
+        escaped = value.to_s.gsub("'", "''")
+        "'#{escaped}'"
+      else
+        value.to_s
+      end
+    end
+  end
+end

data/lib/yerba/location.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Yerba
+  Location = Data.define(:start_line, :start_column, :end_line, :end_column, :start_offset, :end_offset)
+end

data/lib/yerba/map.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Yerba
+  class Map
+    include Enumerable
+
+    attr_reader :selector, :location, :key
+
+    def initialize(document_or_hash = nil, selector = nil, location = nil, key = nil)
+      if document_or_hash.is_a?(Document)
+        @document = document_or_hash
+        @selector = selector
+        @location = location
+        @key = key
+        @data = nil
+      elsif document_or_hash.is_a?(Hash)
+        @document = nil
+        @selector = nil
+        @location = nil
+        @data = document_or_hash
+      else
+        @document = nil
+        @selector = nil
+        @location = nil
+        @data = {}
+      end
+    end
+
+    def [](key)
+      if @document
+        new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
+        @document[new_path]
+      else
+        @data[key]
+      end
+    end
+
+    def []=(key, value)
+      if @document
+        new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
+        @document.set(new_path, value)
+      else
+        @data[key] = value
+      end
+    end
+
+    def insert(key, value, before: nil, after: nil)
+      if @document
+        new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
+        @document.insert(new_path, value.to_s, before: before, after: after)
+      else
+        @data[key] = value
+      end
+
+      self
+    end
+
+    def sort_keys(order)
+      @document&.sort_keys(@selector, order)
+
+      self
+    end
+
+    def keys
+      if @document
+        results = @document.find(@selector)
+        return [] unless results.is_a?(Array) && results.first.is_a?(Hash)
+
+        results.first.keys
+      else
+        @data.keys
+      end
+    end
+
+    def each(&)
+      return enum_for(:each) unless block_given?
+
+      if @document
+        keys.each { |key| yield key, self[key] }
+      else
+        @data.each(&)
+      end
+    end
+
+    def dig(*keys)
+      if @document
+        result = keys.reduce(self) { |node, key| node.nil? ? nil : node[key] }
+        result&.value
+      else
+        @data.dig(*keys)
+      end
+    end
+
+    def delete(key = nil)
+      if key && @document
+        new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
+        @document.delete(new_path)
+      elsif @document
+        @document.delete(@selector)
+      else
+        @data.delete(key)
+      end
+
+      self
+    end
+
+    def key?(key)
+      if @document
+        new_path = @selector.empty? ? key.to_s : "#{@selector}.#{key}"
+        @document.exists?(new_path)
+      else
+        @data.key?(key)
+      end
+    end
+    alias has_key? key?
+    alias include? key?
+
+    def value
+      @data || nil
+    end
+
+    def to_h
+      if @document
+        results = @document.find(@selector)
+        results&.first || {}
+      else
+        @data
+      end
+    end
+    alias to_hash to_h
+
+    def to_yaml
+      to_hash.map do |key, val|
+        formatted = format_value(val)
+        "#{key}: #{formatted}"
+      end.join("\n")
+    end
+
+    def inspect
+      if @document
+        results = @document.find(@selector)
+
+        if results.is_a?(Array) && !results.empty? && results.first.is_a?(Hash)
+          map_keys = results.first.keys.first(5)
+          preview = map_keys.map { |key| "#{key}: #{results.first[key].inspect}" }.join(", ")
+
+          "#<Yerba::Map selector=#{@selector.inspect} {#{preview}}>"
+        else
+          "#<Yerba::Map selector=#{@selector.inspect}>"
+        end
+      else
+        "#<Yerba::Map {#{@data.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")}}>"
+      end
+    end
+
+    private
+
+    def format_value(value)
+      case value
+      when Scalar then value.to_yaml
+      when nil then "null"
+      else value.to_s
+      end
+    end
+  end
+end

data/lib/yerba/scalar.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Yerba
+  class Scalar
+    attr_reader :selector, :location, :key
+
+    def initialize(document_or_value, selector_or_opts = nil, value = nil, location = nil, key = nil, quote_style: nil)
+      if document_or_value.is_a?(Document) || document_or_value.nil?
+        @document = document_or_value
+        @selector = selector_or_opts
+        @value = value
+        @location = location
+        @key = key
+        @quote_style = quote_style
+      else
+        @document = nil
+        @selector = nil
+        @value = document_or_value
+        @location = nil
+        @key = nil
+        @quote_style = selector_or_opts.is_a?(Hash) ? selector_or_opts[:quote_style] : quote_style
+      end
+    end
+
+    def value
+      @value ||= @document&.get(@selector)
+    end
+
+    def quote_style
+      @quote_style || @document&.get_quote_style(@selector)
+    end
+
+    def quote_style=(style)
+      @document&.set_quote_style(@selector, style)
+
+      @quote_style = style
+    end
+
+    def value=(new_value)
+      @document&.set(@selector, new_value)
+      @value = new_value
+    end
+    alias set value=
+
+    def to_s
+      value.to_s
+    end
+
+    def to_str
+      to_s
+    end
+
+    def to_i
+      value.to_i
+    end
+
+    def to_f
+      value.to_f
+    end
+
+    def ==(other)
+      value == other
+    end
+
+    def to_yaml
+      case value
+      when nil then "null"
+      when String then Formatting.quote(value, quote_style)
+      else value.to_s
+      end
+    end
+
+    def delete
+      @document&.delete(@selector)
+    end
+
+    def inspect
+      if @selector
+        "#<Yerba::Scalar selector=#{@selector.inspect} value=#{value.inspect}>"
+      else
+        "#<Yerba::Scalar value=#{value.inspect} quote_style=#{quote_style.inspect}>"
+      end
+    end
+  end
+end

data/lib/yerba/sequence.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Yerba
+  class Sequence
+    include Enumerable
+
+    attr_reader :selector, :location, :key
+
+    def initialize(document_or_array = nil, selector = nil, location = nil, key = nil)
+      if document_or_array.is_a?(Document)
+        @document = document_or_array
+        @selector = selector
+        @location = location
+        @key = key
+        @data = nil
+      elsif document_or_array.is_a?(Array)
+        @document = nil
+        @selector = nil
+        @location = nil
+        @data = document_or_array
+      else
+        @document = nil
+        @selector = nil
+        @location = nil
+        @data = []
+      end
+    end
+
+    def [](index)
+      if @document
+        new_path = "#{@selector}[#{index}]"
+        @document[new_path]
+      else
+        @data[index]
+      end
+    end
+
+    def <<(item)
+      if @document
+        case item
+        when Map
+          @document.insert_object(@selector, item.to_hash)
+        when Hash
+          @document.insert_object(@selector, item)
+        when Scalar
+          @document.insert(@selector, item.to_yaml)
+        else
+          formatted = format_for_insert(item.to_s)
+          @document.insert(@selector, formatted)
+        end
+      else
+        @data << item
+      end
+
+      self
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      length.times { |i| yield self[i] }
+    end
+
+    def length
+      if @document
+        scalar_items = @document.get("#{@selector}[]")
+
+        if scalar_items.is_a?(Array) && !scalar_items.empty?
+          scalar_items.length
+        else
+          data = @document.get_value(@selector)
+          data.is_a?(Array) ? data.length : 0
+        end
+      else
+        @data.length
+      end
+    end
+    alias size length
+
+    def first
+      self[0]
+    end
+
+    def last
+      self[length - 1] # rubocop:disable Style/NegativeArrayIndex
+    end
+
+    def remove(value)
+      @document&.remove(@selector, value.to_s)
+
+      self
+    end
+
+    def delete_at(index)
+      @document&.remove_at(@selector, index)
+
+      self
+    end
+
+    def delete_if
+      return enum_for(:delete_if) unless block_given?
+
+      indices_to_remove = []
+
+      length.times do |index|
+        indices_to_remove << index if yield self[index]
+      end
+
+      indices_to_remove.reverse_each do |index|
+        @document&.remove_at(@selector, index)
+      end
+
+      self
+    end
+
+    def sort(by: nil, case_sensitive: false)
+      @document&.sort(@selector, by: by, case_sensitive: case_sensitive)
+
+      self
+    end
+
+    def delete
+      @document&.delete(@selector)
+    end
+
+    def value
+      items
+    end
+
+    def to_a
+      @data || items
+    end
+    alias to_ary to_a
+
+    def to_yaml
+      items.map do |item|
+        case item
+        when Scalar then "- #{item.to_yaml}"
+        when Map then "- #{item.to_yaml.gsub("\n", "\n  ")}"
+        else "- #{item}"
+        end
+      end.join("\n")
+    end
+
+    def inspect
+      list = items
+      preview = list.first(5).map(&:inspect).join(", ")
+      suffix = list.length > 5 ? ", ... (#{list.length} items)" : ""
+
+      if @selector
+        "#<Yerba::Sequence selector=#{@selector.inspect} [#{preview}#{suffix}]>"
+      else
+        "#<Yerba::Sequence [#{preview}#{suffix}]>"
+      end
+    end
+
+    private
+
+    def format_for_insert(value)
+      Formatting.quote(value, detect_quote_style)
+    end
+
+    def detect_quote_style
+      @document.get_quote_style("#{@selector}[0]")
+    end
+
+    def items
+      if @document
+        result = @document.get("#{@selector}[]")
+
+        if result.is_a?(Array) && !result.empty?
+          result
+        else
+          data = @document.get_value(@selector)
+          data.is_a?(Array) ? data : []
+        end
+      else
+        @data
+      end
+    end
+  end
+end

data/lib/yerba/version.rb

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

data/lib/yerba.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "yerba/version"
+require_relative "yerba/location"
+require_relative "yerba/formatting"
+require_relative "yerba/scalar"
+require_relative "yerba/map"
+require_relative "yerba/sequence"
+require_relative "yerba/document"
+require_relative "yerba/collection"
+
+begin
+  require "yerba/yerba"
+rescue LoadError
+  # C extension not available, fall back to CLI mode
+end
+
+module Yerba
+  class UnsupportedPlatformError < StandardError; end
+  class ExecutableNotFoundError < StandardError; end
+  class CompilationError < StandardError; end
+
+  GEM_NAME = "yerba"
+  EXECUTABLE_NAME = "yerba"
+
+  NATIVE_PLATFORMS = {
+    "arm64-darwin" => "arm64-darwin",
+    "x86_64-darwin" => "x86_64-darwin",
+    "aarch64-linux" => "aarch64-linux",
+    "arm64-linux" => "aarch64-linux",
+    "x86_64-linux" => "x86_64-linux",
+  }.freeze
+
+  def self.executable(exe_path: nil)
+    if exe_path
+      return exe_path if File.executable?(exe_path)
+
+      raise ExecutableNotFoundError, "yerba executable not found at #{exe_path}"
+    end
+
+    if ENV["YERBA_INSTALL_DIR"]
+      install_dir_exe = File.join(ENV["YERBA_INSTALL_DIR"], EXECUTABLE_NAME)
+
+      if File.executable?(install_dir_exe)
+        return install_dir_exe
+      end
+
+      raise ExecutableNotFoundError, "yerba executable not found at #{install_dir_exe} (set by YERBA_INSTALL_DIR)"
+    end
+
+    platform = Gem::Platform.local
+    platform_key = "#{platform.cpu}-#{platform.os}"
+
+    exe_directory = NATIVE_PLATFORMS[platform_key]
+
+    if exe_directory
+      exe_file = File.expand_path(
+        File.join("..", "exe", exe_directory, EXECUTABLE_NAME),
+        __dir__
+      )
+
+      return exe_file if File.executable?(exe_file)
+    end
+
+    compiled = compile_from_source
+
+    return compiled if compiled
+
+    if exe_directory
+      raise ExecutableNotFoundError,
+            "yerba executable not found at exe/#{exe_directory}/yerba. " \
+            "Try reinstalling the gem: gem install yerba"
+    else
+      raise UnsupportedPlatformError,
+            "yerba does not have a precompiled binary for #{platform_key}. " \
+            "Install Rust (https://rustup.rs) and reinstall the gem to compile from source, " \
+            "or set YERBA_INSTALL_DIR to use a custom binary."
+    end
+  end
+
+  def self.compile_from_source
+    rust_dir = File.expand_path(File.join("..", "rust"), __dir__)
+
+    return nil unless File.exist?(File.join(rust_dir, "Cargo.toml"))
+    return nil unless system("cargo --version > /dev/null 2>&1")
+
+    platform = Gem::Platform.local
+    platform_key = "#{platform.cpu}-#{platform.os}"
+    exe_directory = File.join(File.expand_path(File.join("..", "exe", platform_key), __dir__))
+    exe_file = File.join(exe_directory, EXECUTABLE_NAME)
+
+    return exe_file if File.executable?(exe_file)
+
+    warn "yerba: No precompiled binary found. Compiling from source..."
+
+    FileUtils.mkdir_p(exe_directory)
+
+    unless system("cd #{rust_dir} && cargo build --release")
+      raise CompilationError, "Failed to compile yerba from source. Is Rust installed?"
+    end
+
+    source_binary = File.join(rust_dir, "target", "release", EXECUTABLE_NAME)
+
+    unless File.exist?(source_binary)
+      raise CompilationError, "Compilation succeeded but binary not found at #{source_binary}"
+    end
+
+    FileUtils.cp(source_binary, exe_file)
+    FileUtils.chmod(0o755, exe_file)
+
+    exe_file
+  end
+
+  private_class_method :compile_from_source
+
+  def self.parse(content)
+    Document.parse(content)
+  end
+
+  def self.parse_file(path)
+    Document.new(path)
+  end
+
+  def self.document(path)
+    Document.new(path)
+  end
+
+  def self.files(glob)
+    Collection.new(glob)
+  end
+end