rapidyaml_rb 0.1.0-x86_64-linux

data/lib/rapidyaml_rb/core_ext/object.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rapidyaml_rb'
+
+class Object
+  def to_yaml
+    RapidyamlRb.dump(self)
+  end
+end

data/lib/rapidyaml_rb/core_ext/yaml.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'rapidyaml_rb'
+
+module YAML
+  class << self
+    def load(yaml, symbolize_names: false, permitted_classes: [], **_)
+      RapidyamlRb.load(yaml, symbolize_names: symbolize_names, permitted_classes: permitted_classes)
+    end
+
+    def safe_load(yaml, symbolize_names: false, permitted_classes: [], **_)
+      RapidyamlRb.safe_load(yaml, symbolize_names: symbolize_names, permitted_classes: permitted_classes)
+    end
+
+    def unsafe_load(yaml, symbolize_names: false, permitted_classes: [], **_)
+      RapidyamlRb.unsafe_load(yaml, symbolize_names: symbolize_names, permitted_classes: permitted_classes)
+    end
+
+    def dump(obj, **)
+      RapidyamlRb.dump(obj)
+    end
+
+    def safe_dump(obj, **)
+      RapidyamlRb.safe_dump(obj)
+    end
+
+    def dump_stream(*objects)
+      RapidyamlRb.dump_stream(*objects)
+    end
+
+    def load_stream(yaml, symbolize_names: false, permitted_classes: [], **_, &block)
+      RapidyamlRb.load_stream(yaml, symbolize_names: symbolize_names, permitted_classes: permitted_classes, &block)
+    end
+
+    def safe_load_stream(yaml, symbolize_names: false, permitted_classes: [], **_, &block)
+      RapidyamlRb.safe_load_stream(yaml, symbolize_names: symbolize_names, permitted_classes: permitted_classes, &block)
+    end
+
+    def load_file(path, symbolize_names: false, permitted_classes: [], **_)
+      RapidyamlRb.load_file(path, symbolize_names: symbolize_names, permitted_classes: permitted_classes)
+    end
+
+    def unsafe_load_file(path, symbolize_names: false, permitted_classes: [], **_)
+      RapidyamlRb.unsafe_load_file(path, symbolize_names: symbolize_names, permitted_classes: permitted_classes)
+    end
+  end
+end

data/lib/rapidyaml_rb/core_ext.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Optional core extensions. Load explicitly:
+#   require "rapidyaml_rb/core_ext"
+#
+# Provides:
+#   Object#to_yaml  — serializes any object via RapidyamlRb.dump
+#   YAML.*          — patches load/dump family to use RapidyamlRb
+
+require_relative 'core_ext/object'
+require_relative 'core_ext/yaml'

data/lib/rapidyaml_rb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RapidyamlRb
+  VERSION = '0.1.0'
+end

data/lib/rapidyaml_rb.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'psych'
+require_relative 'rapidyaml_rb/version'
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "rapidyaml_rb/#{Regexp.last_match(1)}/rapidyaml_rb"
+rescue LoadError
+  require 'rapidyaml_rb/rapidyaml_rb'
+end
+
+module RapidyamlRb
+  # Error and SyntaxError are defined in the C extension (Init_rapidyaml_rb).
+  # ParseError is kept as an alias for backward compatibility.
+  ParseError = SyntaxError
+
+  # Regex patterns for scalar coercion during load.
+  # Only applied when the corresponding class is in permitted_classes.
+  DATE_RE     = /\A(\d{4})-(\d{2})-(\d{2})\z/
+  DATETIME_RE = /\A\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?: ?(?:Z|[+-]\d{2}:?\d{2}))?\z/
+
+  module_function
+
+  # Parses a YAML string and returns the corresponding Ruby object.
+  #
+  # @param yaml [String] YAML-formatted string
+  # @param symbolize_names [Boolean] if true, hash keys are returned as symbols
+  # @param permitted_classes [Array<Class>] classes allowed for type coercion
+  #   (supports Symbol, Date, Time)
+  # @return [Object] parsed Ruby object
+  # @raise [RapidyamlRb::SyntaxError] if the YAML is invalid
+  def load(yaml, symbolize_names: false, permitted_classes: [])
+    result = Ext.parse(yaml)
+    result = coerce_scalars(result, permitted_classes) unless permitted_classes.empty?
+    symbolize_names ? deep_symbolize_keys(result) : result
+  end
+
+  # Alias matching Psych.safe_load; rapidyaml does not execute arbitrary code,
+  # so this is equivalent to load for all practical purposes.
+  #
+  # @param yaml [String] YAML-formatted string
+  # @param symbolize_names [Boolean] if true, hash keys are returned as symbols
+  # @param permitted_classes [Array<Class>] classes allowed for type coercion
+  # @return [Object] parsed Ruby object
+  # @raise [RapidyamlRb::SyntaxError] if the YAML is invalid
+  def safe_load(yaml, symbolize_names: false, permitted_classes: [])
+    load(yaml, symbolize_names: symbolize_names, permitted_classes: permitted_classes)
+  end
+
+  # Serializes a Ruby object to a YAML string.
+  #
+  # @param obj [Object] Ruby object to serialize
+  # @return [String] YAML representation
+  # @raise [RapidyamlRb::Error] if the object cannot be serialized
+  def dump(obj)
+    Ext.emit(obj)
+  end
+
+  # Serializes multiple Ruby objects into a multi-document YAML stream.
+  #
+  # @param objects [Array<Object>] Ruby objects to serialize
+  # @return [String] YAML stream with one document per object
+  # @raise [RapidyamlRb::Error] if any object cannot be serialized
+  def dump_stream(*objects)
+    objects.map do |obj|
+      s = dump(obj)
+      obj.is_a?(Hash) || obj.is_a?(Array) ? "---\n#{s}" : "--- #{s}"
+    end.join
+  end
+
+  # Equivalent to dump; rapidyaml does not serialize arbitrary Ruby objects,
+  # so there is no unsafe surface to restrict.
+  #
+  # @param obj [Object] Ruby object to serialize
+  # @return [String] YAML representation
+  def safe_dump(obj)
+    dump(obj)
+  end
+
+  # Returns the version string of the bundled rapidyaml C++ library.
+  # Psych exposes libyaml_version; this is the equivalent for rapidyaml.
+  #
+  # @return [String] rapidyaml version, e.g. "0.13.0"
+  def libyaml_version
+    Ext.ryml_version
+  end
+
+  # Parses all YAML documents in a string and yields each as a Ruby object.
+  # If no block given, returns an array of all documents.
+  #
+  # @param yaml [String] YAML-formatted string (may contain multiple documents)
+  # @param symbolize_names [Boolean] if true, hash keys are returned as symbols
+  # @param permitted_classes [Array<Class>] classes allowed for type coercion
+  # @yield [Object] each parsed document
+  # @return [Array, nil] array of documents if no block given
+  def load_stream(yaml, symbolize_names: false, permitted_classes: [], &block)
+    result = Ext.parse_stream(yaml)
+    docs = result.is_a?(Array) ? result : [result]
+    docs = docs.map { |d| coerce_scalars(d, permitted_classes) } unless permitted_classes.empty?
+    docs = docs.map { |d| deep_symbolize_keys(d) } if symbolize_names
+    if block
+      docs.each(&block)
+      nil
+    else
+      docs
+    end
+  end
+
+  # @see load_stream
+  def safe_load_stream(yaml, symbolize_names: false, permitted_classes: [], &block)
+    load_stream(yaml, symbolize_names: symbolize_names,
+                      permitted_classes: permitted_classes, &block)
+  end
+
+  # Alias matching Psych.unsafe_load; rapidyaml never executes arbitrary Ruby
+  # object tags, so this is equivalent to load.
+  #
+  # @param yaml [String] YAML-formatted string
+  # @param symbolize_names [Boolean] if true, hash keys are returned as symbols
+  # @param permitted_classes [Array<Class>] classes allowed for type coercion
+  # @return [Object] parsed Ruby object
+  def unsafe_load(yaml, symbolize_names: false, permitted_classes: [])
+    load(yaml, symbolize_names: symbolize_names, permitted_classes: permitted_classes)
+  end
+
+  # Alias matching Psych.unsafe_load_file; rapidyaml never executes arbitrary
+  # Ruby object tags, so this is equivalent to load_file.
+  #
+  # @param path [String] path to the YAML file
+  # @param symbolize_names [Boolean] if true, hash keys are returned as symbols
+  # @param permitted_classes [Array<Class>] classes allowed for type coercion
+  # @return [Object] parsed Ruby object
+  def unsafe_load_file(path, symbolize_names: false, permitted_classes: [])
+    load_file(path, symbolize_names: symbolize_names, permitted_classes: permitted_classes)
+  end
+
+  # Parses YAML from a file and returns the corresponding Ruby object.
+  #
+  # @param path [String] path to the YAML file
+  # @param symbolize_names [Boolean] if true, hash keys are returned as symbols
+  # @param permitted_classes [Array<Class>] classes allowed for type coercion
+  # @return [Object] parsed Ruby object
+  # @raise [RapidyamlRb::SyntaxError] if the YAML is invalid
+  # @raise [Errno::ENOENT] if the file does not exist
+  def load_file(path, symbolize_names: false, permitted_classes: [])
+    load(File.read(path), symbolize_names: symbolize_names,
+                          permitted_classes: permitted_classes)
+  end
+
+  # Serializes a Ruby object to a YAML file.
+  #
+  # @param obj [Object] Ruby object to serialize
+  # @param path [String] destination file path
+  # @return [void]
+  # @raise [RapidyamlRb::Error] if the object cannot be serialized
+  def dump_file(obj, path)
+    File.write(path, dump(obj))
+  end
+
+  # @api private
+  def coerce_scalars(obj, permitted_classes)
+    permit_symbol = permitted_classes.any? { |c| c == Symbol || c.to_s == 'Symbol' }
+    permit_date   = permitted_classes.any? { |c| c == Date   || c.to_s == 'Date' }
+    permit_time   = permitted_classes.any? { |c| c == Time   || c.to_s == 'Time' }
+    coerce_scalars_inner(obj, permit_symbol, permit_date, permit_time)
+  end
+  private_class_method :coerce_scalars
+
+  # @api private
+  def coerce_scalars_inner(obj, permit_symbol, permit_date, permit_time)
+    case obj
+    when Hash
+      obj.transform_keys { |k| coerce_scalars_inner(k, permit_symbol, permit_date, permit_time) }
+         .transform_values { |v| coerce_scalars_inner(v, permit_symbol, permit_date, permit_time) }
+    when Array
+      obj.map { |v| coerce_scalars_inner(v, permit_symbol, permit_date, permit_time) }
+    when String
+      coerce_string(obj, permit_symbol, permit_date, permit_time)
+    else
+      obj
+    end
+  end
+  private_class_method :coerce_scalars_inner
+
+  # @api private
+  def coerce_string(str, permit_symbol, permit_date, permit_time)
+    if permit_symbol && str.start_with?(':')
+      name = str[1..]
+      return name.empty? ? :"" : name.to_sym
+    end
+    if permit_time && str =~ DATETIME_RE && str.include?(':')
+      begin
+        require 'time'
+        t = Time.parse(str)
+        return t
+      rescue ArgumentError
+        # fall through
+      end
+    end
+    if permit_date && str =~ DATE_RE
+      begin
+        require 'date'
+        return Date.new(::Regexp.last_match(1).to_i, ::Regexp.last_match(2).to_i, ::Regexp.last_match(3).to_i)
+      rescue ArgumentError
+        # fall through
+      end
+    end
+    str
+  end
+  private_class_method :coerce_string
+
+  # @api private
+  def deep_symbolize_keys(obj)
+    case obj
+    when Hash
+      obj.transform_keys(&:to_sym).transform_values { |v| deep_symbolize_keys(v) }
+    when Array
+      obj.map { |v| deep_symbolize_keys(v) }
+    else
+      obj
+    end
+  end
+  private_class_method :deep_symbolize_keys
+end

data/rapidyaml_rb.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'lib/rapidyaml_rb/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'rapidyaml_rb'
+  spec.version     = RapidyamlRb::VERSION
+  spec.authors     = ['Durable Programming LLC']
+  spec.email       = ['commercial@durableprogramming.com']
+  spec.summary     = 'Fast YAML parsing and emission via rapidyaml — drop-in Psych replacement'
+  spec.description = 'Ruby bindings to rapidyaml (ryml), a C++ YAML library. ' \
+                     'Exposes a Psych-compatible API so it can be used as a drop-in replacement.'
+  spec.homepage    = 'https://github.com/durableprogramming/rapidyaml-rb'
+  spec.license     = 'MIT'
+  spec.required_ruby_version = '>= 3.1.0'
+
+  spec.metadata = {
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => spec.homepage,
+    'changelog_uri' => "#{spec.homepage}/blob/main/CHANGELOG.md",
+    'rubygems_mfa_required' => 'true'
+  }
+
+  spec.files = Dir[
+    'lib/**/*',
+    'ext/**/*',
+    'LICENSE',
+    'rapidyaml_rb.gemspec'
+  ].reject { |f| File.directory?(f) }
+
+  spec.extensions = ['ext/rapidyaml_rb/extconf.rb']
+
+  spec.add_development_dependency 'minitest',            '~> 5.0'
+  spec.add_development_dependency 'rake',                '~> 13.0'
+  spec.add_development_dependency 'rake-compiler',       '~> 1.2'
+  spec.add_development_dependency 'rake-compiler-dock',  '~> 1.4'
+  spec.add_development_dependency 'rice',                '~> 4.0'
+  spec.add_development_dependency 'rubocop',             '> 1.86.0'
+  spec.add_development_dependency 'rubocop-minitest',    '> 0.39.0'
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: rapidyaml_rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: x86_64-linux
+authors:
+- Durable Programming LLC
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler-dock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 1.86.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 1.86.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 0.39.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 0.39.0
+description: Ruby bindings to rapidyaml (ryml), a C++ YAML library. Exposes a Psych-compatible
+  API so it can be used as a drop-in replacement.
+email:
+- commercial@durableprogramming.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- ext/rapidyaml_rb/extconf.rb
+- ext/rapidyaml_rb/rapidyaml_rb.cpp
+- ext/rapidyaml_rb/ryml_all.hpp
+- lib/rapidyaml_rb.rb
+- lib/rapidyaml_rb/3.0/rapidyaml_rb.so
+- lib/rapidyaml_rb/3.1/rapidyaml_rb.so
+- lib/rapidyaml_rb/3.2/rapidyaml_rb.so
+- lib/rapidyaml_rb/3.3/rapidyaml_rb.so
+- lib/rapidyaml_rb/3.4/rapidyaml_rb.so
+- lib/rapidyaml_rb/4.0/rapidyaml_rb.so
+- lib/rapidyaml_rb/core_ext.rb
+- lib/rapidyaml_rb/core_ext/object.rb
+- lib/rapidyaml_rb/core_ext/yaml.rb
+- lib/rapidyaml_rb/version.rb
+- rapidyaml_rb.gemspec
+homepage: https://github.com/durableprogramming/rapidyaml-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/durableprogramming/rapidyaml-rb
+  source_code_uri: https://github.com/durableprogramming/rapidyaml-rb
+  changelog_uri: https://github.com/durableprogramming/rapidyaml-rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Fast YAML parsing and emission via rapidyaml — drop-in Psych replacement
+test_files: []