red-black-tree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4f43951dbc99839bcb925622284650c9f5ec3dbe3fa709706fac32345bbe1607
+  data.tar.gz: 8d1d5cdc4420b9e29012ed4a16054f0bede9b9239327605151f97efc123d0636
+SHA512:
+  metadata.gz: b3f59b93fc6d1f5e10081f5f72d9c8346c4e117badc7f3ac5d694bac07308c511fc3ed71cb4b250c5d790fd6d77f13b219fd1d9accbd7120783147862ce52045
+  data.tar.gz: 42d421b0ab688c03ea073ef34d460ed42cb3de4f14b5aa13ec4f243bf71fbc65533da0a2a7ee390ea33fc5828549bc62f514f3a592c0f42d179f3d4a693c6ab2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-08-04
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Joshua Young
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# RedBlackTree
+
+[Red-black tree](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree) data structure for Ruby.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+```ruby
+Work = Struct.new :min_latency, keyword_init: true
+
+class WorkNode < RedBlackTree::Node
+  def <=> other
+    if other.instance_of? RedBlackTree::LeafNode
+      1
+    else
+      self.data.min_latency <=> other.data.min_latency
+    end
+  end
+end
+
+tree = RedBlackTree.new
+
+tree << WorkNode.new(Work.new min_latency: 1.2)
+tree << WorkNode.new(Work.new min_latency: 0.8)
+tree << WorkNode.new(Work.new min_latency: 0.8)
+tree << WorkNode.new(Work.new min_latency: 0.4)
+
+until tree.empty?
+  work = tree.shift # 0.4, 0.8, 0.8, 1.2
+  # process work
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` to run the
+tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/joshuay03/red-black-tree.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the RedBlackTree project's codebases, issue trackers, chat rooms and mailing lists is expected
+to follow the [code of conduct](https://github.com/joshuay03/red-black-tree/blob/main/CODE_OF_CONDUCT.md).

data/lib/red-black-tree.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require_relative "red_black_tree/utils"
+require_relative "red_black_tree/node"
+require_relative "red_black_tree/node/leaf_node"
+
+class RedBlackTree
+  include Utils
+
+  # @return [Integer] the number of valid/non-leaf nodes
+  attr_reader :size
+
+  # @private
+  # @return [RedBlackTree::Node, nil] the root node
+  attr_reader :root
+
+  # @private
+  # @return [RedBlackTree::Node, nil] the left most node
+  attr_reader :left_most_node
+
+  def initialize
+    @size = 0
+    @left_most_node = nil
+  end
+
+  # Returns true if there are no valid/non-leaf nodes, and false if there are.
+  #
+  # @return [true, false]
+  def empty?
+    @size == 0
+  end
+
+  # Returns true if there are any valid/non-leaf nodes, and false if there are none.
+  #
+  # @return [true, false]
+  def any?
+    !empty?
+  end
+
+  # Removes the left most node (the node with the lowest data value) from the tree.
+  #
+  # @return [RedBlackTree::Node, nil] the removed node
+  def shift
+    node = @left_most_node
+    delete! node if node
+    node
+  end
+
+  # Traverses the tree, comparing existing nodes to the node to be added,
+  # and inserts the node with the appropriate parent and direction.
+  #
+  # @param node [RedBlackTree::Node] the node to be added
+  # @return [RedBlackTree] self
+  def << node
+    raise ArgumentError, "cannot add leaf node" if node.instance_of? LeafNode
+
+    parent = @root
+    direction = nil
+
+    while parent
+      direction = node >= parent ? Node::RIGHT : Node::LEFT
+      break if (child = parent[direction]).leaf?
+
+      parent = child
+    end
+
+    insert! node, parent, direction
+  end
+  alias_method :add!, :<<
+
+  # Inserts the given node using the given direction relative to the given parent.
+  #
+  # @private ideally this is only used internally e.g. in #<< which has context on the ideal location for the node
+  # @param node [RedBlackTree::Node] the node to be inserted
+  # @param target_parent [RedBlackTree::Node, nil] the parent under which the node should be inserted
+  # @param direction ["left", "right", nil] the direction of the node relative to the parent
+  # @return [RedBlackTree] self
+  def insert! node, target_parent = nil, direction = nil
+    raise ArgumentError, "cannot insert leaf node" if node.instance_of? LeafNode
+
+    if target_parent.nil?
+      raise ArgumentError, "Target parent must be provided for tree with root" if @root
+    else
+      raise ArgumentError, "Target parent direction must be provided" if direction.nil?
+      raise ArgumentError, "Target parent already has #{direction} child" if (child = target_parent[direction]) && child.valid?
+    end
+
+    opp_direction = opposite_direction direction if direction
+
+    node.parent = nil
+    node.left = LeafNode.new
+    node.left.parent = node
+    node.right = LeafNode.new
+    node.right.parent = node
+
+    if target_parent.nil?
+      @root = node
+      @root.black!
+    else
+      target_parent[direction] = node
+      node.parent = target_parent
+      node.red!
+
+      while node.parent && node.parent.red? do
+        if node.parent.sibling && node.parent.sibling.red?
+          node.parent.black!
+          node.parent.sibling.black!
+          node.parent.parent.red!
+          node = node.parent.parent
+        else
+          if node.position == direction
+            node = node.parent
+            rotate_sub_tree! node, opp_direction
+          end
+
+          node.parent.black!
+
+          if node.parent.parent
+            node.parent.parent.red!
+            rotate_sub_tree! node.parent.parent, direction
+          end
+        end
+
+        @root.black!
+      end
+    end
+
+    node.validate! @root == node
+
+    increment_size!
+    update_left_most_node!
+
+    self
+  end
+
+  # Removes the given node from the tree.
+  #
+  # @param node [RedBlackTree::Node] the node to be removed
+  # @return [RedBlackTree] self
+  def delete! node
+    raise ArgumentError, "cannot delete leaf node" if node.instance_of? LeafNode
+
+    if node.children_are_valid?
+      successor = node.left
+      successor = successor.left until successor.left.leaf?
+      node.swap_data_with! successor
+
+      return delete! successor
+    elsif node.single_child_is_valid?
+      is_root = is_root? node
+
+      valid_child = node.children.find(&:valid?)
+      node.swap_data_with! valid_child
+      node.black!
+
+      @root = node if is_root
+
+      return delete! valid_child
+    elsif node.children_are_leaves?
+      if is_root? node
+        @root = nil
+      elsif node.red?
+        leaf = LeafNode.new
+        node.swap_position_with! leaf
+      else
+        direction = node.position
+        opp_direction = opposite_direction direction
+
+        loop do
+          if node.sibling.valid? && node.sibling.red?
+            node.parent.red!
+            node.sibling.black!
+            rotate_sub_tree! node.parent, direction
+
+            next
+          end
+
+          if node.distant_nephew && node.distant_nephew.valid? && node.distant_nephew.red?
+            case node.parent.colour
+            when Node::RED then node.sibling.red!
+            when Node::BLACK then node.sibling.black!
+            end
+            node.parent.black!
+            node.distant_nephew.black!
+            rotate_sub_tree! node.parent, direction
+
+            break
+          end
+
+          if node.close_nephew && node.close_nephew.valid? && node.close_nephew.red?
+            node.sibling.red!
+            node.close_nephew.black!
+            rotate_sub_tree! node.sibling, opp_direction
+
+            next
+          end
+
+          if node.parent.red?
+            node.sibling.red!
+            node.parent.black!
+
+            break
+          end
+
+          break
+        end
+
+        leaf = LeafNode.new
+        node.swap_position_with! leaf
+      end
+    end
+
+    node.validate_free!
+
+    decrement_size!
+    update_left_most_node!
+
+    self
+  end
+
+  private
+
+  def is_root? node
+    node.object_id == @root.object_id
+  end
+
+  # Rotates a (sub-)tree starting from the given node in the given direction.
+  #
+  # @param node [RedBlackTree::Node] the root node of the sub-tree
+  # @param direction ["left", "right"] the direction of rotation
+  # @return [RedBlackTree::Node] the new root node of the sub-tree
+  def rotate_sub_tree! node, direction
+    opp_direction = opposite_direction direction
+    opp_direction_child = node[opp_direction]
+    return node unless opp_direction_child.valid?
+
+    node[opp_direction] = opp_direction_child[direction]
+    opp_direction_child[direction].parent = node
+
+    opp_direction_child.parent = node.parent
+    if node.parent
+      node.parent[node.position] = opp_direction_child
+    else
+      @root = opp_direction_child
+    end
+
+    opp_direction_child[direction] = node
+    node.parent = opp_direction_child
+
+    opp_direction_child
+  end
+
+  def increment_size!
+    @size += 1
+  end
+
+  def decrement_size!
+    @size -= 1
+  end
+
+  def update_left_most_node!
+    unless @root
+      @left_most_node = nil
+      return
+    end
+
+    current = @root
+    current = current.left until current.left.leaf?
+    @left_most_node = current
+  end
+end

data/lib/red_black_tree/node/leaf_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+class RedBlackTree
+  class LeafNode < Node # @private
+    def initialize
+      super nil
+
+      @colour = BLACK
+    end
+
+    def <=> other
+      (other.instance_of? LeafNode) ? 0 : -1
+    end
+  end
+end

data/lib/red_black_tree/node/left_right_element_referencers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class RedBlackTree
+  class Node
+    module LeftRightElementReferencers # @private
+      def [] direction
+        case direction
+        when Node::LEFT then @left
+        when Node::RIGHT then @right
+        else raise ArgumentError, "Direction must be one of #{DIRECTIONS}"
+        end
+      end
+
+      def []= direction, node
+        case direction
+        when Node::LEFT then @left = node
+        when Node::RIGHT then @right = node
+        else raise ArgumentError, "Direction must be one of #{DIRECTIONS}"
+        end
+      end
+    end
+  end
+end

data/lib/red_black_tree/node.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "utils"
+require_relative "node/left_right_element_referencers"
+
+class RedBlackTree
+  class Node
+    include Comparable
+
+    # @return [any] the data/value representing the node
+    attr_reader :data
+
+    # @param data [any] a non-nil data/value representing the node
+    # @return [Node] a new instance of Node
+    def initialize data
+      raise ArgumentError, "data cannot be nil" if data.nil? && !(instance_of? RedBlackTree::LeafNode)
+
+      @data = data
+      @colour = nil
+      @parent = @left = @right = nil
+
+      validate_free!
+    end
+
+    # Needs to be implemented in a subclass of {Node}.
+    # Will be used to calculate the ideal position of this node when adding it
+    # to a tree.
+    def <=> other
+      raise NotImplementedError, "Comparable operator <=> must be implemented in subclass"
+    end
+
+    module Implementation # @private
+      class StructuralError < StandardError; end
+
+      include Utils
+
+      RED = "red"
+      BLACK = "black"
+      COLOURS = [RED, BLACK].freeze
+
+      LEFT = "left"
+      RIGHT = "right"
+      DIRECTIONS = [LEFT, RIGHT].freeze
+
+      attr_reader :colour
+      attr_writer :data
+      attr_accessor :tree, :parent
+      attr_accessor :left, :right
+      include LeftRightElementReferencers
+
+      def red? = @colour == RED
+      def red! = @colour = RED
+
+      def black? = @colour == BLACK
+      def black! = @colour = BLACK
+
+      def leaf? = black? && (instance_of? RedBlackTree::LeafNode)
+      def valid? = (red? || black?) && !(instance_of? RedBlackTree::LeafNode)
+
+      def children_are_leaves? = children.all?(&:leaf?)
+      def children_are_valid? = children.all?(&:valid?)
+      def single_child_is_leaf? = children.any?(&:leaf?) && !children_are_leaves?
+      alias_method :single_child_is_valid?, :single_child_is_leaf?
+
+      def position
+        return unless @parent
+
+        case self
+        when @parent.left then LEFT
+        when @parent.right then RIGHT
+        else raise StructuralError, "Disowned by parent"
+        end
+      end
+
+      def opposite_position
+        return unless @parent
+
+        opposite_direction position
+      end
+
+      def children
+        [@left, @right]
+      end
+
+      def sibling
+        return unless @parent
+
+        @parent[opposite_position]
+      end
+
+      def close_nephew
+        return unless sibling
+
+        sibling[position]
+      end
+
+      def distant_nephew
+        return unless sibling
+
+        sibling[opposite_position]
+      end
+
+      def validate! is_root = false
+        return if (@parent || is_root) && @left && @right
+
+        raise StructuralError, "Node is invalid"
+      end
+
+      def validate_free!
+        anchors = []
+        anchors << "parent" if @parent
+        anchors << "left child" if @left && @left.valid?
+        anchors << "right child" if @right && @right.valid?
+        return if anchors.empty?
+
+        raise StructuralError, "Node is still chained to #{anchors.join(", ")}"
+      end
+
+      def swap_data_with! other_node
+        temp_data = @data
+        @data = other_node.data
+        other_node.data = temp_data
+      end
+
+      def swap_colour_with! other_node
+        temp_colour = @colour
+
+        case other_node.colour
+        when RED then red!
+        when BLACK then black!
+        end
+
+        case temp_colour
+        when RED then other_node.red!
+        when BLACK then other_node.black!
+        end
+      end
+
+      def swap_position_with! other_node
+        self_position = position
+        other_position = other_node.position
+
+        if other_node.parent == self
+          self[other_position] = other_node[other_position]
+          other_node[other_position] = self
+
+          other_node.parent = @parent
+          @parent = other_node
+        elsif other_node == @parent
+          other_node[self_position] = self[self_position]
+          self[self_position] = other_node
+
+          temp_parent = other_node.parent
+          other_node.parent = self
+          @parent = temp_parent
+        else
+          other_node.parent[other_position] = self if other_node.parent
+          @parent[self_position] = other_node if @parent
+
+          temp_parent = other_node.parent
+          other_node.parent = @parent
+          @parent = temp_parent
+        end
+      end
+    end
+
+    self.include Implementation
+  end
+end

data/lib/red_black_tree/utils.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class RedBlackTree
+  module Utils # @private
+    private
+
+    def opposite_direction direction
+      case direction
+      when "up" then "down"
+      when "right" then "left"
+      when "down" then "up"
+      when "left" then "right"
+      else raise ArgumentError, "Invalid direction"
+      end
+    end
+  end
+end

data/lib/red_black_tree/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class RedBlackTree
+  VERSION = "0.1.0"
+end

data/red-black-tree.gemspec

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "lib/red_black_tree/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "red-black-tree"
+  spec.version = RedBlackTree::VERSION
+  spec.authors = ["Joshua Young"]
+  spec.email = ["djry1999@gmail.com"]
+
+  spec.summary = "Red-Black Tree Data Structure for Ruby"
+  spec.homepage = "https://github.com/joshuay03/red-black-tree"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = "https://joshuay03.github.io/red-black-tree/"
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir["{lib}/**/*", "**/*.{gemspec,md,txt}"]
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: red-black-tree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joshua Young
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-03 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- djry1999@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- lib/red-black-tree.rb
+- lib/red_black_tree/node.rb
+- lib/red_black_tree/node/leaf_node.rb
+- lib/red_black_tree/node/left_right_element_referencers.rb
+- lib/red_black_tree/utils.rb
+- lib/red_black_tree/version.rb
+- red-black-tree.gemspec
+homepage: https://github.com/joshuay03/red-black-tree
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/joshuay03/red-black-tree
+  documentation_uri: https://joshuay03.github.io/red-black-tree/
+  source_code_uri: https://github.com/joshuay03/red-black-tree
+  changelog_uri: https://github.com/joshuay03/red-black-tree/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.15
+signing_key:
+specification_version: 4
+summary: Red-Black Tree Data Structure for Ruby
+test_files: []