lite-containers 0.0.5

data/lib/lite/containers/avl_tree/delete.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lite
+  module Containers
+    class AvlTree
+      module Delete
+        def delete(key, node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+          return [nil, nil] if node.nil?
+
+          case compare(key, node.key)
+          when -1
+            deleted, node.left = delete(key, node.left)
+            [deleted, rebalance(node)]
+          when 0
+            if node.left.nil? || node.right.nil?
+              new_root = node.left.nil? ? node.right : node.left
+              [node, new_root]
+            else
+              new_root = leftmost_child(node.right)
+              _, new_root.right = delete(new_root.key, node.right)
+              new_root.left = node.left
+              [node, rebalance(new_root)]
+            end
+          when 1
+            deleted, node.right = delete(key, node.right)
+            [deleted, rebalance(node)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/find.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/comparison'
+
+module Lite
+  module Containers
+    class AvlTree
+      module Find
+        def leftmost_child(node)
+          return node if node.left.nil?
+
+          leftmost_child(node.left)
+        end
+
+        def rightmost_child(node)
+          return node if node.right.nil?
+
+          rightmost_child(node.right)
+        end
+
+        module Exact
+          def find(key, node)
+            return nil unless node
+
+            case compare(key, node.key)
+            when -1
+              find(key, node.left)
+            when 0
+              node
+            when 1
+              find(key, node.right)
+            end
+          end
+        end
+
+        module Inexact
+          def find(key, node)
+            exact, candidate = find_candidate(key, node)
+            exact || candidate
+          end
+
+          def find_candidate(key, node)
+            return [nil, nil] unless node
+
+            case lookup_direction(key, node.key)
+            when -1
+              find_candidate(key, lookup_path(node, -1))
+            when 0
+              [node, nil]
+            when 1
+              exact, candidate = find_candidate(key, lookup_path(node, 1))
+              if exact
+                [exact, nil]
+              elsif candidate
+                [nil, candidate]
+              else
+                [nil, node]
+              end
+            end
+          end
+        end
+
+        module ExactOrNearestBackwards
+          include Inexact
+
+          def lookup_direction(search_key, node_key)
+            compare(search_key, node_key)
+          end
+
+          def lookup_path(node, comparison_result)
+            case comparison_result
+            when -1 then node.left
+            when 1 then node.right
+            else
+              raise Helpers::Comparison::Error, "Unexpected comparison result: #{comparison_result}"
+            end
+          end
+        end
+
+        module ExactOrNearestForwards
+          include Inexact
+
+          def lookup_direction(search_key, node_key)
+            compare(node_key, search_key)
+          end
+
+          def lookup_path(node, comparison_result)
+            case comparison_result
+            when -1 then node.right
+            when 1 then node.left
+            else
+              raise Helpers::Comparison::Error, "Unexpected comparison result: #{comparison_result}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/implementation.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+require_relative '../helpers/comparison'
+require_relative 'insert'
+require_relative 'delete'
+require_relative 'balance'
+require_relative 'traversal'
+require_relative 'find'
+
+module Lite
+  module Containers
+    class AvlTree
+      class Error < Containers::Error; end
+
+      module Implementation
+        def self.instance(type)
+          type = type.to_sym
+          case type
+          when :max then Max
+          when :min then Min
+          else raise Error, Error, "Unexpected AVL tree type: '#{type}'"
+          end
+        end
+
+        include Balance
+        include Delete
+        include Insert
+        include Find
+        include Traversal
+
+        module Max
+          extend Implementation
+
+          module Compare
+            def compare(a, b)
+              Helpers::Comparison::Max.compare(a, b)
+            end
+          end
+
+          module Exact
+            extend Find::Exact
+            extend Compare
+          end
+
+          module ExactOrNearestForwards
+            extend Find::ExactOrNearestForwards
+            extend Compare
+          end
+
+          module ExactOrNearestBackwards
+            extend Find::ExactOrNearestBackwards
+            extend Compare
+          end
+
+          extend Compare
+        end
+
+        module Min
+          extend Implementation
+
+          module Compare
+            def compare(a, b)
+              Helpers::Comparison::Min.compare(a, b)
+            end
+          end
+
+          module Exact
+            extend Find::Exact
+            extend Compare
+          end
+
+          module ExactOrNearestForwards
+            extend Find::ExactOrNearestForwards
+            extend Compare
+          end
+
+          module ExactOrNearestBackwards
+            extend Find::ExactOrNearestBackwards
+            extend Compare
+          end
+
+          extend Compare
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/insert.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Lite
+  module Containers
+    class AvlTree
+      module Insert
+        def insert(node, key, value, merge, factory)
+          return true, factory.instance(key, value) if node.nil?
+
+          case compare(key, node.key)
+          when -1
+            increment, node.left = insert(node.left, key, value, merge, factory)
+            [increment, rebalance(node)]
+          when 0
+            node.value = merge.merge(node.value, value)
+            [false, node]
+          when 1
+            increment, node.right = insert(node.right, key, value, merge, factory)
+            [increment, rebalance(node)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/interfaces/bracket_assign.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'key_extraction_strategy/explicit'
+require_relative '../../helpers/merge'
+
+module Lite
+  module Containers
+    class AvlTree
+      module Interfaces
+        module BracketAssign
+          include KeyExtractionStrategy::Explicit
+
+          module Instance
+            def instance(type, **opts)
+              raise ArgumentError, 'Disallowed keyword argument: merge' if opts.key?(:merge)
+
+              super(type, merge: :replace, **opts)
+            end
+          end
+
+          def self.included(base)
+            KeyExtractionStrategy::Abstract.enforce_exclusion!(base, KeyExtractionStrategy::Explicit)
+            base.extend Instance
+          end
+
+          def []=(key, value)
+            insert_pair key, value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/interfaces/key_extraction_strategy/abstract.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../../../error'
+
+module Lite
+  module Containers
+    class AvlTree
+      module Interfaces
+        module KeyExtractionStrategy
+          module Abstract
+            def self.included(base)
+              register(base)
+              enforce_exclusion(base, base)
+            end
+
+            def self.register(strategy)
+              registry << strategy
+            end
+
+            def self.registry
+              @registry ||= Set.new
+            end
+
+            def self.enforce_exclusion(mod, strategy)
+              mod.define_singleton_method :included do |base|
+                Abstract.enforce_exclusion!(base, strategy)
+                super(base)
+              end
+            end
+
+            def self.enforce_exclusion!(base, strategy)
+              conflicts = Abstract
+                          .registry
+                          .select { |candidate| strategy != candidate && base < candidate }
+                          .map { |conflict| conflict.name.split('::').last }
+
+              if !conflicts.empty?
+                raise Error, "Key extraction strategy conflict: #{conflicts.join(', ')}"
+              elsif base.is_a?(Module)
+                Abstract.enforce_exclusion(base, strategy)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/interfaces/key_extraction_strategy/explicit.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative '../../node'
+
+module Lite
+  module Containers
+    class AvlTree
+      module Interfaces
+        module KeyExtractionStrategy
+          module Explicit
+            class Node < AvlTree::Node
+              def out
+                [key, value]
+              end
+            end
+
+            include Abstract
+
+            def insert(key, value)
+              insert_pair(key, value)
+            end
+
+            private
+
+            def node_factory
+              Node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/interfaces/key_extraction_strategy/implicit.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../../helpers/key_extractor'
+require_relative '../../../abstract/implicit_key'
+require_relative '../../node'
+require_relative 'abstract'
+
+module Lite
+  module Containers
+    class AvlTree
+      module Interfaces
+        module KeyExtractionStrategy
+          module Implicit
+            include Abstract
+            include Containers::Abstract::ImplicitKey
+
+            class Node < AvlTree::Node
+              def out
+                value
+              end
+            end
+
+            module Instance
+              def instance(type, key_extractor: nil, **opts)
+                super(type, key_extractor: Helpers::KeyExtractor.instance(key_extractor), **opts)
+              end
+            end
+
+            def self.included(base)
+              Abstract.enforce_exclusion!(base, self)
+              base.extend Instance
+            end
+
+            def initialize(*args, key_extractor:, **opts)
+              @key_extractor = key_extractor
+              super(*args, **opts)
+            end
+
+            def push(value)
+              key = extract_key(value)
+              insert_pair key, value
+            end
+
+            private
+
+            def extract_key(object)
+              return object if @key_extractor.nil?
+
+              @key_extractor.to_key(object)
+            end
+
+            def node_factory
+              Node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/node.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lite
+  module Containers
+    class AvlTree
+      class Node
+        attr_reader :key
+        attr_accessor :value, :height, :left, :right
+
+        def self.instance(key, value)
+          new key, value
+        end
+
+        private_class_method :new
+
+        def initialize(key, value)
+          @key = key
+          @value = value
+          @height = 1
+          @left = nil
+          @right = nil
+        end
+
+        def out
+          raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+        end
+
+        def inspect
+          lr = "#{left.nil? ? 0 : :L}|#{right.nil? ? 0 : :R}"
+          "#<#{self.class.name} @key: #{key}, @value: #{value}, @height: #{height} #{lr}"
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree/traversal.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Lite
+  module Containers
+    class AvlTree
+      module Traversal
+        def traverse(node, yielder, from:, to:)
+          return unless node
+
+          after_start = after_back_guard?(node, from)
+          traverse(node.left, yielder, from: from, to: to) if after_start
+          return unless before_front_guard?(node, to)
+
+          yielder.yield node.out if after_start
+          traverse(node.right, yielder, from: from, to: to)
+        end
+
+        def reverse_traverse(node, yielder, from:, to:)
+          return unless node
+
+          after_start = before_front_guard?(node, from)
+          reverse_traverse(node.right, yielder, from: from, to: to) if after_start
+          return unless after_back_guard?(node, to)
+
+          yielder.yield node.out if after_start
+          reverse_traverse(node.left, yielder, from: from, to: to)
+        end
+
+        def after_back_guard?(node, guard)
+          return true if guard.nil?
+
+          compare(guard, node.key) < 1
+        end
+
+        def before_front_guard?(node, guard)
+          return true if guard.nil?
+
+          compare(node.key, guard) < 1
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/avl_tree.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/merge'
+require_relative 'avl_tree/implementation'
+require_relative 'avl_tree/interfaces/key_extraction_strategy/explicit'
+require_relative 'avl_tree/interfaces/key_extraction_strategy/implicit'
+require_relative 'abstract/collection'
+require_relative 'abstract/deque'
+require_relative 'abstract/sorted_map'
+
+module Lite
+  module Containers
+    class AvlTree # rubocop:disable Metrics/ClassLength
+      include Abstract::Collection
+      include Abstract::Deque
+      include Abstract::SortedMap
+      include Enumerable
+
+      class ExplicitKey < AvlTree
+        include Interfaces::KeyExtractionStrategy::Explicit
+      end
+
+      class ImplicitKey < AvlTree
+        include Interfaces::KeyExtractionStrategy::Implicit
+      end
+
+      attr_reader :size
+
+      def self.instance(type, merge: nil, **opts)
+        impl = Implementation.instance(type)
+        merge = Helpers::Merge.instance(merge)
+        new(impl, merge, **opts)
+      end
+
+      private_class_method :new
+
+      def initialize(impl, merge)
+        @impl = impl
+        @merge = merge
+        reset!
+      end
+
+      def reset!
+        @root = nil
+        @size = 0
+      end
+
+      def key?(key)
+        !find_with_finder(key, @impl::Exact).nil?
+      end
+
+      def [](key)
+        find_with_finder(key, @impl::Exact)&.value
+      end
+
+      def find(key)
+        find_with_finder(key, @impl::Exact)&.out
+      end
+
+      def find_or_nearest_backwards(key)
+        find_with_finder(key, @impl::ExactOrNearestBackwards)&.out
+      end
+
+      def find_or_nearest_forwards(key)
+        find_with_finder(key, @impl::ExactOrNearestForwards)&.out
+      end
+
+      def delete(key)
+        deleted, @root = @impl.delete(key, @root)
+        @size -= 1 if deleted
+        deleted&.out
+      end
+
+      def each(&block)
+        if block
+          traverse.each(&block)
+          self
+        else
+          traverse
+        end
+      end
+
+      def reverse_each(&block)
+        if block
+          reverse_traverse.each(&block)
+          self
+        else
+          reverse_traverse
+        end
+      end
+
+      def traverse(from: nil, to: nil)
+        Enumerator.new do |yielder|
+          @impl.traverse @root, yielder, from: from, to: to
+        end
+      end
+
+      def reverse_traverse(from: nil, to: nil)
+        Enumerator.new do |yielder|
+          @impl.reverse_traverse @root, yielder, from: from, to: to
+        end
+      end
+
+      def front
+        fetch_front&.out
+      end
+
+      def pop_front
+        node = fetch_front
+        return unless node
+
+        delete(node.key)
+        node.out
+      end
+
+      def back
+        fetch_back&.out
+      end
+
+      def pop_back
+        node = fetch_back
+        return unless node
+
+        delete(node.key)
+        node.out
+      end
+
+      def drain!
+        array = reverse_traverse.to_a
+        reset!
+        array
+      end
+
+      private
+
+      def fetch_front
+        return if @root.nil?
+
+        @impl.rightmost_child(@root)
+      end
+
+      def fetch_back
+        return if @root.nil?
+
+        @impl.leftmost_child(@root)
+      end
+
+      def insert_pair(key, value)
+        increment, @root = @impl.insert(@root, key, value, @merge, node_factory)
+        @size += 1 if increment
+        self
+      end
+
+      def find_with_finder(key, finder)
+        finder.find(key, @root)
+      end
+    end
+  end
+end

data/lib/lite/containers/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lite
+  module Containers
+    class Error < StandardError; end
+  end
+end