lite-containers 0.0.5

data/lib/lite/containers/heap.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/comparison'
+require_relative 'abstract/collection'
+require_relative 'abstract/queue'
+require_relative 'abstract/implicit_key'
+
+module Lite
+  module Containers
+    class Heap # rubocop:disable Metrics/ClassLength
+      include Abstract::Collection
+      include Abstract::ImplicitKey
+      include Abstract::Queue
+
+      class Error < StandardError; end
+
+      def self.instance(type, key_extractor: nil)
+        comparison = Helpers::Comparison.instance(type, key_extractor: key_extractor)
+        with_comparison(comparison)
+      end
+
+      def self.with_comparison(comparison)
+        new(comparison)
+      end
+
+      private_class_method :new
+
+      def initialize(comparison)
+        @comparison = comparison
+        reset!
+        freeze
+      end
+
+      def size
+        @array.size
+      end
+
+      def top
+        @array.first
+      end
+
+      def front
+        top
+      end
+
+      def push(value)
+        @array.push value
+        sift_up(length - 1)
+        self
+      end
+
+      def replace_top(value)
+        sift_down(0, value)
+      end
+
+      def pop
+        return if length.zero?
+
+        if length == 1
+          @array.pop
+        else
+          value = top
+          sift_down(0, @array.pop)
+          value
+        end
+      end
+
+      def pop_front
+        pop
+      end
+
+      def drain!
+        result = []
+        result << pop while length.positive?
+        result
+      end
+
+      def reset!
+        if frozen?
+          @array.clear
+        else
+          @array = []
+        end
+      end
+
+      private
+
+      def parent_index(index)
+        ((index - 1) / 2)
+      end
+
+      def left_child_value(parent_index)
+        index = left_child_index(parent_index)
+        @array[index]
+      end
+
+      def left_child_index(index)
+        (2 * index) + 1
+      end
+
+      def right_child_value(parent_index)
+        index = right_child_index(parent_index)
+        @array[index]
+      end
+
+      def right_child_index(index)
+        (2 * index) + 2
+      end
+
+      def sift_up(index)
+        continue = true
+        while continue && index.positive?
+          parent_index = parent_index(index)
+          if greater? @array[index], @array[parent_index]
+            @array[parent_index], @array[index] = @array[index], @array[parent_index]
+            index = parent_index
+          else
+            continue = false
+          end
+        end
+      end
+
+      def sift_down(index, replacement)
+        not_leaf_index = (length / 2) - 1
+        while index <= not_leaf_index
+          child_index = left_greater?(index) ? left_child_index(index) : right_child_index(index)
+          @array[index] = @array[child_index]
+          index = child_index
+        end
+        sift_up_replacement(index, replacement)
+      end
+
+      def sift_up_replacement(index, replacement)
+        @array[index] = replacement
+        sift_up(index)
+      end
+
+      def balanced_for_left?(parent_value, parent_index)
+        value = left_child_value(parent_index)
+        return true if value.nil?
+
+        less_than_or_equal?(value, parent_value)
+      end
+
+      def balanced_for_right?(parent_value, parent_index)
+        value = right_child_value(parent_index)
+        return true if value.nil?
+
+        less_than_or_equal?(value, parent_value)
+      end
+
+      def left_greater?(index)
+        left_value = left_child_value(index)
+        right_value = right_child_value(index)
+        return true if right_value.nil?
+
+        greater? left_value, right_value
+      end
+
+      def less_than_or_equal?(a, b)
+        @comparison.compare(a, b) < 1
+      end
+
+      def greater?(a, b)
+        @comparison.compare(a, b).positive?
+      end
+    end
+  end
+end

data/lib/lite/containers/helpers/comparison.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Lite
+  module Containers
+    module Helpers
+      module Comparison
+        class Error < Containers::Error; end
+
+        def self.instance(type, key_extractor: nil)
+          type = type.to_sym
+          case type
+          when :max then Max.instance(key_extractor)
+          when :min then Min.instance(key_extractor)
+          else raise Error, "Unexpected comparison type: '#{type}'"
+          end
+        end
+
+        class Abstract
+          def initialize(key_extractor)
+            @key_extractor = key_extractor
+            freeze
+          end
+
+          def to_key(element)
+            @key_extractor.call(element)
+          end
+
+          def for_item(item)
+            method(:compare).curry.call(item)
+          end
+
+          def for_key(key)
+            comparison = self.class
+            proc do |b|
+              comparison.compare(key, to_key(b))
+            end
+          end
+
+          def compare(a, b)
+            self.class.compare(to_key(a), to_key(b))
+          end
+
+          class << self
+            def to_key(element)
+              element
+            end
+
+            def for_item(item)
+              method(:compare).curry.call(item)
+            end
+
+            alias for_key for_item
+          end
+        end
+
+        class Max < Abstract
+          def invert
+            Comparison.instance :min, key_extractor: @key_extractor
+          end
+
+          class << self
+            def instance(key_extractor)
+              key_extractor ? new(key_extractor) : self
+            end
+
+            def compare(a, b)
+              result = a <=> b
+              raise Error, "No meaningful comparison between #{a} <=> #{b}" if result.nil?
+
+              result
+            end
+
+            def invert
+              Min
+            end
+          end
+        end
+
+        class Min < Abstract
+          def invert
+            Comparison.instance :max, key_extractor: @key_extractor
+          end
+
+          class << self
+            def instance(key_extractor)
+              key_extractor ? new(key_extractor) : self
+            end
+
+            def compare(a, b)
+              result = b <=> a
+              raise Error, "No meaningful comparison between #{a} <=> #{b}" if result.nil?
+
+              result
+            end
+
+            def invert
+              Max
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/helpers/key_extractor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Lite
+  module Containers
+    module Helpers
+      class KeyExtractor
+        def self.instance(input)
+          return if input.nil?
+          return input if input.respond_to? :to_key
+          return new input if input.is_a? Proc
+
+          raise Error, "Expected nil, key extractor or a proc, got #{input.inspect}"
+        end
+
+        private_class_method :new
+
+        def initialize(block)
+          @block = block
+        end
+
+        def to_key(element)
+          @block.call(element)
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/helpers/merge.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Lite
+  module Containers
+    module Helpers
+      module Merge
+        class Error < Containers::Error; end
+
+        def self.instance(strategy)
+          case strategy
+          when nil, :replace then Replace
+          when :keep then Keep
+          when Proc then Custom.new(strategy)
+          else raise Error, "Unexpected strategy for merge: #{strategy}"
+          end
+        end
+
+        class Replace
+          def self.merge(_old, fresh)
+            fresh
+          end
+        end
+
+        class Keep
+          def self.merge(old, _fresh)
+            old
+          end
+        end
+
+        class Custom
+          def initialize(proc)
+            @proc = proc
+            freeze
+          end
+
+          def merge(old, fresh)
+            proc.call(old, fresh)
+          end
+
+          private
+
+          attr_reader :proc
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/sorted_array/binary_search.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/comparison'
+
+module Lite
+  module Containers
+    class SortedArray
+      module BinarySearch
+        def self.position_of(sorted_array, key, comparison: Helpers::Comparison::Max)
+          comparator = comparison.for_key(key)
+          find_position(sorted_array, comparator)
+        end
+
+        def self.find_position(sorted_array, comparator)
+          upper = sorted_array.length
+          lower = 0
+          found = false
+          index = lower
+
+          while !found && upper > lower
+            index = midpoint(lower, upper)
+            candidate = sorted_array[index]
+            result = comparator.call(candidate)
+            if result.zero?
+              found = true
+            elsif result.negative?
+              upper = index
+            else
+              index += 1
+              lower = index
+            end
+          end
+          [found, index]
+        end
+
+        def self.midpoint(lower, upper)
+          ((upper - lower) / 2) + lower
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/sorted_array.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+require_relative 'helpers/comparison'
+require_relative 'helpers/merge'
+require_relative 'sorted_array/binary_search'
+require_relative 'abstract/collection'
+require_relative 'abstract/deque'
+require_relative 'abstract/implicit_key'
+require_relative 'abstract/sorted_map'
+
+module Lite
+  module Containers
+    class SortedArray # rubocop:disable Metrics/ClassLength
+      include Abstract::Collection
+      include Enumerable
+      include Abstract::ImplicitKey
+      include Abstract::Deque
+      include Abstract::SortedMap
+
+      class Error < Containers::Error; end
+
+      attr_reader :comparator
+
+      def self.from_unsorted(type, array, key_extractor: nil, merge: nil)
+        comparison = comparison(type, key_extractor)
+        sorted = array.sort { |a, b| comparison.compare(a, b) }
+        construct(sorted, comparison, merge)
+      end
+
+      def self.from_sorted(type, array, key_extractor: nil, merge: nil)
+        comparison = comparison(type, key_extractor)
+        sorted = ensure_sorted!(array, comparison)
+        construct(sorted, comparison, merge)
+      end
+
+      def self.from_sorted_unsafe(type, sorted, key_extractor: nil, merge: nil)
+        comparison = comparison(type, key_extractor)
+        construct(sorted, comparison, merge)
+      end
+
+      def self.comparison(type, key_extractor)
+        Helpers::Comparison.instance(type, key_extractor: key_extractor)
+      end
+
+      def self.construct(sorted, comparison, merge)
+        merge = Helpers::Merge.instance(merge)
+        deduplicated = handle_duplicates(sorted, comparison, merge)
+        new(deduplicated, comparison, merge)
+      end
+
+      def self.handle_duplicates(array, comparison, merge)
+        chunks = array.chunk_while { |a, b| comparison.compare(a, b).zero? }
+        chunks.map do |chunk|
+          first, *rest = chunk
+          next first if rest.empty?
+
+          rest.reduce(first) do |last, current|
+            merge.merge(last, current)
+          end
+        end
+      end
+
+      def self.ensure_sorted!(array, comparison)
+        array.each_cons(2) do |a, b|
+          raise Error, 'Input array is not sorted' unless comparison.compare(a, b) < 1
+        end
+        array
+      end
+
+      private_class_method :new, :comparison, :construct, :handle_duplicates, :ensure_sorted!
+
+      def initialize(array, comparison, merge)
+        @comparison = comparison
+        @merge = merge
+        @array = array.freeze
+      end
+
+      def drain!
+        array = @array
+        @array = []
+        array.reverse
+      end
+
+      def size
+        @array.size
+      end
+
+      def index_of(item)
+        found, index = position_of(item)
+        return unless found
+
+        index
+      end
+
+      def position_of(item)
+        BinarySearch.find_position(@array, comparison.for_item(item))
+      end
+
+      def each(&block)
+        if block
+          array.each(&block)
+          self
+        else
+          array.each
+        end
+      end
+
+      def to_array
+        array
+      end
+
+      def front
+        array.last
+      end
+
+      def pop_front
+        *rest, item = @array
+        @array = rest.freeze
+        item
+      end
+
+      def back
+        array.first
+      end
+
+      def pop_back
+        item, *rest = @array
+        @array = rest.freeze
+        item
+      end
+
+      def [](index)
+        array[index]
+      end
+
+      def key?(key)
+        found, = BinarySearch.position_of(@array, key, comparison: comparison)
+        found
+      end
+
+      def find(key)
+        found, index = BinarySearch.position_of(@array, key, comparison: comparison)
+        self[index] if found
+      end
+
+      def find_or_nearest_backwards(key)
+        found, position = BinarySearch.position_of(@array, key, comparison: comparison)
+        return self[position] if found
+        return if position.zero?
+
+        self[position - 1]
+      end
+
+      def find_or_nearest_forwards(key)
+        _, position = BinarySearch.position_of(@array, key, comparison: comparison)
+        self[position]
+      end
+
+      def remove_at(index)
+        return if index.negative?
+
+        before = array[0...index]
+        to_remove = array[index]
+        after = array[(index + 1)..]
+        @array = [*before, *after].freeze
+        to_remove
+      end
+
+      def push(item)
+        found, position = position_of(item)
+        item = handle_duplicate(position, item) if found
+        before = array[0...position]
+        keep_from = found ? position + 1 : position
+        after = array[keep_from..]
+        @array = [*before, item, *after].freeze
+      end
+
+      private
+
+      attr_reader :array, :comparison, :merge
+
+      def handle_duplicate(index, fresh)
+        merge.merge(array[index], fresh)
+      end
+    end
+  end
+end

data/lib/lite/containers/top_n/abstract.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'error'
+require_relative '../abstract/collection'
+require_relative '../abstract/implicit_key'
+require_relative '../top_n'
+
+module Lite
+  module Containers
+    module TopN
+      module Abstract
+        include Containers::Abstract::Collection
+        include Containers::Abstract::ImplicitKey
+        extend Forwardable
+
+        def_delegator(:@backend, :size)
+
+        def initialize(backend, limit, filter)
+          @backend = backend
+          @limit = limit
+          @filter = filter
+        end
+
+        attr_reader :limit
+
+        def push(new_item)
+          return unless pass?(new_item)
+
+          @backend.push(new_item)
+          shrink
+        end
+
+        def drain!
+          @backend.drain!
+        end
+
+        private
+
+        def pass?(item)
+          return true if @filter.nil?
+
+          @filter.call(item)
+        end
+
+        def shrink
+          return [] if @limit.nil?
+
+          drop = []
+          drop << pop while @backend.size > @limit
+          drop
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative 'deque'
+require_relative '../avl_tree'
+
+module Lite
+  module Containers
+    module TopN
+      class AvlTree
+        include Deque
+        include Abstract
+
+        Backend = Containers::AvlTree::ImplicitKey
+
+        def self.instance(type, limit: nil, filter: nil, **backend_options)
+          backend = Backend.instance(type, **backend_options)
+          new backend, limit, filter
+        end
+      end
+
+      register_backend :avl_tree, AvlTree
+    end
+  end
+end

data/lib/lite/containers/top_n/deque.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../abstract/deque'
+
+module Lite
+  module Containers
+    module TopN
+      module Deque
+        include Containers::Abstract::Deque
+
+        def pop
+          pop_back
+        end
+
+        def front
+          @backend.front
+        end
+
+        def pop_front
+          @backend.pop_front
+        end
+
+        def back
+          @backend.back
+        end
+
+        def pop_back
+          @backend.pop_back
+        end
+      end
+    end
+  end
+end

data/lib/lite/containers/top_n/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Lite
+  module Containers
+    module TopN
+      class Error < RuntimeError; end
+    end
+  end
+end