sorted_containers 0.1.1 → 1.1.0

data/lib/sorted_containers/sorted_set.rb

@@ -2,12 +2,38 @@
 
 require "set"
 require_relative "sorted_array"
+require "forwardable"
 
 # A module that provides sorted container data structures.
 module SortedContainers
-  # The SortedSet class is a sorted set implementation.
+  # rubocop:disable Metrics/ClassLength
+
+  # SortedSet is a set that maintains its elements in sorted order.
+  #
+  # SortedSet has most of the same methods as Set, but also has the following
+  # additional methods:
+  # - #bisect_left
+  # - #bisect_right
+  # - #delete_at
+  # - #last
+  # - #[]
+  #
+  # Addtionally, there are methods that work differently than their Set counterparts.
+  # Generally, methods that use Entry Order will use the sort order of the keys instead.
+  # For example:
+  #
+  #   s = Set.new
+  #   s.add(2)
+  #   s.add(1)
+  #   s.first # => 2
+  #
+  #   ss = SortedSet.new
+  #   ss.add(2)
+  #   ss.add(1)
+  #   ss.first # => 1
   class SortedSet
     include Enumerable
+    extend Forwardable
 
     # Initializes a new instance of the SortedSet class.
     #
@@ -15,12 +41,158 @@ module SortedContainers
     # @param load_factor [Integer] The load factor for the sorted set.
     def initialize(iterable = [], load_factor: SortedArray::DEFAULT_LOAD_FACTOR)
       @set = Set.new(iterable)
-      @list = SortedContainers::SortedArray.new(@set.to_a, load_factor: load_factor)
+      @list = SortedContainers::SortedArray.new(@set, load_factor: load_factor)
     end
 
-    # Adds an item to the sorted set.
+    # Creates a new instance of the SortedSet class.
     #
-    # @param item [Object] The item to be added.
+    # @param args [Array] The initial elements of the sorted set.
+    # @return [SortedSet] A new instance of the SortedSet class.
+    def self.[](*args)
+      new(args)
+    end
+
+    # @!method []
+    #   @see SortedArray#[]
+    # @!method to_a
+    #   @see SortedArray#to_a
+    # @!method join
+    #   @see SortedArray#join
+    # @!method first
+    #   @see SortedArray#first
+    # @!method last
+    #   @see SortedArray#last
+    # @!method bisect_left
+    #   @see SortedArray#bisect_left
+    # @!method bisect_right
+    #   @see SortedArray#bisect_right
+    def_delegators :@list,
+                   :[],
+                   :to_a,
+                   :join,
+                   :first,
+                   :last,
+                   :bisect_left,
+                   :bisect_right
+
+    # @!method ===
+    #   @see Set#===
+    # @!method classify
+    #   @see Set#classify
+    # @!method include?
+    #   @see Set#include?
+    # @!method member?
+    #   @see Set#member?
+    # @!method size
+    #   @see Set#size
+    # @!method length
+    #   @see Set#length
+    # @!method disjoint?
+    #   @see Set#disjoint?
+    # @!method divide
+    #   @see Set#divide
+    # @!method empty?
+    #   @see Set#empty?
+    # @!method to_set
+    #   @see Set#to_set
+    def_delegators :@set,
+                   :===,
+                   :classify,
+                   :include?,
+                   :member?,
+                   :size,
+                   :length,
+                   :disjoint?,
+                   :divide,
+                   :empty?,
+                   :to_set
+
+    # @see Set#<=>
+    def <=>(other)
+      @set <=> other.set
+    end
+
+    # @see Set#==
+    def ==(other)
+      @set == other.set
+    end
+
+    # @see Set#intersect?
+    def intersect?(other)
+      @set.intersect?(other.set)
+    end
+
+    # @see Set#subset?
+    def subset?(other)
+      @set.subset?(other.set)
+    end
+    alias <= subset?
+
+    # @see Set#superset?
+    def superset?(other)
+      @set.superset?(other.set)
+    end
+    alias >= superset?
+
+    # @see Set#proper_subset?
+    def proper_subset?(other)
+      @set.proper_subset?(other.set)
+    end
+    alias < proper_subset?
+
+    # @see Set#proper_superset?
+    def proper_superset?(other)
+      @set.proper_superset?(other.set)
+    end
+    alias > proper_superset?
+
+    # @see Set#intersection
+    def intersection(other)
+      SortedSet.new(@set & other.set, load_factor: @list.load_factor)
+    end
+    alias & intersection
+
+    # @see Set#union
+    def union(other)
+      SortedSet.new(@set + other.set, load_factor: @list.load_factor)
+    end
+    alias + union
+    alias | union
+
+    # @see Set#difference
+    def difference(other)
+      SortedSet.new(@set - other.set, load_factor: @list.load_factor)
+    end
+    alias - difference
+
+    # @see Set#^
+    def ^(other)
+      SortedSet.new(@set ^ other.set, load_factor: @list.load_factor)
+    end
+
+    # Clears the sorted set. Removes all elements.
+    # @return [SortedSet] The sorted set.
+    def clear
+      @set.clear
+      @list.clear
+      self
+    end
+
+    # @see Set#collect!
+    def collect!
+      return enum_for(:collect!) unless block_given?
+
+      @list.collect! do |item|
+        new_item = yield(item)
+        @set.delete(item)
+        @set.add(new_item)
+        new_item
+      end
+      self
+    end
+    alias map! collect!
+
+    # @see Set#add
     def add(item)
       return if @set.include?(item)
 
@@ -29,42 +201,54 @@ module SortedContainers
     end
     alias << add
 
-    # Retrieves the item at the specified index.
-    #
-    # @param index [Integer] The index of the item to retrieve.
-    def [](index)
-      @list[index]
+    # @see Set#add?
+    def add?(item)
+      return false if @set.include?(item)
+
+      @set.add(item)
+      @list.add(item)
+      self
     end
 
     # Returns a string representation of the sorted set.
     #
     # @return [String] A string representation of the sorted set.
     def to_s
-      "SortedSet(#{to_a.join(", ")})"
+      "#<SortedSet: {#{to_a.join(", ")}}>"
     end
+    alias inspect to_s
 
-    # Retrieves the first item in the sorted set.
-    #
-    # @return [Object] The first item.
-    def first
-      @list.first
-    end
+    # @see Set#delete
+    def delete(item)
+      return self unless @set.include?(item)
 
-    # Retrieves the last item in the sorted set.
-    #
-    # @return [Object] The last item.
-    def last
-      @list.last
+      @set.delete(item)
+      @list.delete(item)
+      self
     end
 
-    # Removes an item from the sorted set.
-    #
-    # @param item [Object] The item to be removed.
-    def delete(item)
-      return unless @set.include?(item)
+    # @see Set#delete?
+    def delete?(item)
+      return unless @set.include?(item) # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
 
       @set.delete(item)
       @list.delete(item)
+      self
+    end
+
+    # @see Set#delete_if
+    def delete_if
+      return enum_for(:delete_if) unless block_given?
+
+      @list.delete_if do |item|
+        if yield(item)
+          @set.delete(item)
+          true
+        else
+          false
+        end
+      end
+      self
     end
 
     # Removes the item at the specified index.
@@ -78,61 +262,116 @@ module SortedContainers
       item
     end
 
-    # Returns the number of items in the sorted set.
-    #
-    # @return [Integer] The number of items.
-    def size
-      @list.size
+    # @see Set#each
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      @list.each(&block)
+      self
     end
 
-    # Checks if an item is included in the sorted set.
-    #
-    # @param item [Object] The item to be checked.
-    # @return [Boolean] `true` if the item is included, `false` otherwise.
-    def include?(item)
-      @set.include?(item)
+    # @see Set#select!
+    def select!
+      return enum_for(:select!) unless block_given?
+
+      @list.filter! do |item|
+        if yield(item)
+          @set.delete(item)
+          true
+        else
+          false
+        end
+      end
+      self
     end
+    alias filter! select!
 
-    # Returns an index to insert `value` in the sorted list.
-    #
-    # If the `value` is already present, the insertion point will be before
-    # (to the left of) any existing values.
-    #
-    # Runtime complexity: `O(log(n))` -- approximate.
-    #
-    # @see SortedArray#bisect_left
-    # @param value [Object] The value to insert.
-    # @return [Integer] The index to insert the value.
-    def bisect_left(value)
-      @list.bisect_left(value)
+    # @see Set#flatten
+    def flatten(level = 1)
+      SortedSet.new(@list.flatten(level), load_factor: @list.load_factor)
     end
 
-    # Returns an index to insert `value` in the sorted list.
-    #
-    # If the `value` is already present, the insertion point will be after
-    # (to the right of) any existing values.
-    #
-    # Runtime complexity: `O(log(n))` -- approximate.
-    #
-    # @see SortedArray#bisect_right
-    # @param value [Object] The value to insert.
-    # @return [Integer] The index to insert the value.
-    def bisect_right(value)
-      @list.bisect_right(value)
+    # @see Set#flatten!
+    def flatten!(level = 1)
+      @set.clear
+      @list.flatten!(level)
+      @set.merge(@list)
+      self
     end
 
-    # Returns the items in the sorted set as an array.
-    #
-    # @return [Array] The items in the sorted set.
-    def to_a
-      @list.to_a
+    # @see Set#keep_if
+    def keep_if
+      return enum_for(:keep_if) unless block_given?
+
+      @list.keep_if do |item|
+        if yield(item)
+          @set.delete(item)
+          true
+        else
+          false
+        end
+      end
+      self
     end
 
-    # Iterates over each item in the sorted set.
-    #
-    # @yield [item] Gives each item to the block.
-    def each(&block)
-      @list.each(&block)
+    # @see Set#merge
+    def merge(other)
+      @set.merge(other.set)
+      @list.clear
+      @list.update(@set)
+      self
+    end
+
+    # rubocop:disable Metrics/MethodLength
+
+    # @see Set#reject!
+    def reject!
+      return enum_for(:reject!) unless block_given?
+
+      changed = false
+      @list.reject! do |item|
+        if yield(item)
+          @set.delete(item)
+          changed = true
+          true
+        else
+          false
+        end
+      end
+      changed ? self : nil
     end
+
+    # rubocop:enable Metrics/MethodLength
+
+    # @see Set#replace
+    def replace(other)
+      @set.replace(other.set)
+      @list.clear
+      @list.update(@set)
+      self
+    end
+
+    # @see Set#reset
+    def reset
+      values = @list.to_a
+      @set.clear
+      @list.clear
+      @set.merge(values)
+      @list.update(values)
+      self
+    end
+
+    # @see Set#subtract
+    def subtract(other)
+      @set.subtract(other.set)
+      @list.clear
+      @list.update(@set)
+      self
+    end
+
+    protected
+
+    attr_reader :set, :list
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/sorted_containers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SortedContainers
-  VERSION = "0.1.1"
+  VERSION = "1.1.0"
 end

data/lib/sorted_containers.rb

@@ -4,3 +4,4 @@ require_relative "sorted_containers/version"
 require_relative "sorted_containers/sorted_array"
 require_relative "sorted_containers/sorted_set"
 require_relative "sorted_containers/sorted_hash"
+require_relative "sorted_containers/core_extensions"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorted_containers
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Garrison Jensen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-26 00:00:00.000000000 Z
+date: 2024-10-16 00:00:00.000000000 Z
 dependencies: []
 description: A collection of sorted containers including SortedArray, SortedDict,
   and SortedSet.
@@ -26,6 +26,7 @@ files:
 - README.md
 - Rakefile
 - lib/sorted_containers.rb
+- lib/sorted_containers/core_extensions.rb
 - lib/sorted_containers/sorted_array.rb
 - lib/sorted_containers/sorted_hash.rb
 - lib/sorted_containers/sorted_set.rb
@@ -55,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: A collection of sorted containers including SortedArray, SortedDict, and