array-sort 0.1.1 → 1.0.0

metadata

@@ -1,89 +1,67 @@
 --- !ruby/object:Gem::Specification
 name: array-sort
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Leo Liang
-autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2018-05-11 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.16'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.16'
-- !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: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-description: Implements sorting algorithms such as merge sort, bubble sort, heap sort,
-  etc. for Arrays.
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: '22 sorting algorithms (merge sort, quicksort, Timsort, introsort, radix
+  sort, smoothsort and more) with the same interface as Array#sort, #sort!, #sort_by
+  and #sort_by!, available as Array methods, refinements or module functions, plus
+  a tracer to watch them work.'
 email:
 - developer@leoliang.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rubocop.yml"
-- ".travis.yml"
-- Gemfile
-- Gemfile.lock
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
-- Rakefile
-- array-sort.gemspec
-- bin/console
-- bin/setup
 - lib/array/sort.rb
-- lib/array/sort/bubble_sort.rb
-- lib/array/sort/heap_sort.rb
-- lib/array/sort/helper.rb
-- lib/array/sort/insertion_sort.rb
-- lib/array/sort/merge_sort.rb
-- lib/array/sort/quick_sort.rb
-- lib/array/sort/version.rb
+- lib/array_sort.rb
+- lib/array_sort/algorithms/binary_insertion_sort.rb
+- lib/array_sort/algorithms/bubble_sort.rb
+- lib/array_sort/algorithms/bucket_sort.rb
+- lib/array_sort/algorithms/cocktail_shaker_sort.rb
+- lib/array_sort/algorithms/comb_sort.rb
+- lib/array_sort/algorithms/counting_sort.rb
+- lib/array_sort/algorithms/cycle_sort.rb
+- lib/array_sort/algorithms/gnome_sort.rb
+- lib/array_sort/algorithms/heap_sort.rb
+- lib/array_sort/algorithms/insertion_sort.rb
+- lib/array_sort/algorithms/intro_sort.rb
+- lib/array_sort/algorithms/merge_sort.rb
+- lib/array_sort/algorithms/odd_even_sort.rb
+- lib/array_sort/algorithms/pancake_sort.rb
+- lib/array_sort/algorithms/quick_sort.rb
+- lib/array_sort/algorithms/radix_sort.rb
+- lib/array_sort/algorithms/selection_sort.rb
+- lib/array_sort/algorithms/shell_sort.rb
+- lib/array_sort/algorithms/smooth_sort.rb
+- lib/array_sort/algorithms/tim_sort.rb
+- lib/array_sort/algorithms/tournament_sort.rb
+- lib/array_sort/algorithms/tree_sort.rb
+- lib/array_sort/array_methods.rb
+- lib/array_sort/core.rb
+- lib/array_sort/functions.rb
+- lib/array_sort/refinements.rb
+- lib/array_sort/registry.rb
+- lib/array_sort/trace.rb
+- lib/array_sort/version.rb
+- sig/array_sort.rbs
 homepage: https://github.com/foxhatleo/array-sort
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  source_code_uri: https://github.com/foxhatleo/array-sort
+  changelog_uri: https://github.com/foxhatleo/array-sort/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/foxhatleo/array-sort/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -91,16 +69,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Implementations of popular sorting algorithms for Arrays.
 test_files: []

data/.gitignore

@@ -1,9 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-/.idea/

data/.rubocop.yml

@@ -1,11 +0,0 @@
-Style/Documentation:
-  Enabled: false
-
-#Naming/FileName:
-#  Enabled: true
-
-Metrics/LineLength:
-  Max: 120
-
-Layout/TrailingWhitespace:
-  Enabled: false

data/.travis.yml

@@ -1,6 +0,0 @@
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.5.1
-before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
-
-# Specify your gem's dependencies in array-sort.gemspec
-gemspec

data/Gemfile.lock

@@ -1,22 +0,0 @@
-PATH
-  remote: .
-  specs:
-    array-sort (0.1.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    minitest (5.11.3)
-    rake (10.5.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  array-sort!
-  bundler (~> 1.16)
-  minitest (~> 5.0)
-  rake (~> 10.0)
-
-BUNDLED WITH
-   1.16.1

data/Rakefile

@@ -1,10 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
-end
-
-task :default => :test

data/array-sort.gemspec

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'array/sort/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'array-sort'
-  spec.version       = ArraySort::VERSION
-  spec.authors       = ['Leo Liang']
-  spec.email         = ['developer@leoliang.com']
-
-  spec.summary       = 'Implementations of popular sorting algorithms for Arrays.'
-  spec.description   = 'Implements sorting algorithms such as merge sort, bubble sort, heap sort, etc. for Arrays.'
-  spec.homepage      = 'https://github.com/foxhatleo/array-sort'
-  spec.license       = 'MIT'
-
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  # if spec.respond_to?(:metadata)
-  #   spec.metadata['allowed_push_host'] = 'TODO: Set to \'http://mygemserver.com\''
-  # else
-  #   raise 'RubyGems 2.0 or newer is required to protect against ' \
-  #     'public gem pushes.'
-  # end
-
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'minitest', '~> 5.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
-end

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "array/sort"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/lib/array/sort/bubble_sort.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-class Array
-  # Returns a new array created by sorting +self+, using bubble sort algorithm.
-  #
-  # Comparisons for the sort will be done using the <=> operator or using an optional code block.
-  #
-  # The block must implement a comparison between +a+ and +b+ and return an integer less than 0 when +b+ follows +a+,
-  # +0+ when +a+ and +b+ are equivalent, or an integer greater than 0 when +a+ follows +b+.
-  #
-  # The result is guaranteed to be stable. When the comparison of two elements returns +0+, the order of the elements
-  # will be preserved.
-  #
-  # @return [Array] the sorted array
-  def bubble_sort(&block)
-    dup.bubble_sort!(&block)
-  end
-
-  # Sorts +self+ in place, using bubble sort algorithm.
-  #
-  # Comparisons for the sort will be done using the <=> operator or using an optional code block.
-  #
-  # The block must implement a comparison between +a+ and +b+ and return an integer less than 0 when +b+ follows +a+,
-  # +0+ when +a+ and +b+ are equivalent, or an integer greater than 0 when +a+ follows +b+.
-  #
-  # The result is guaranteed to be stable. When the comparison of two elements returns +0+, the order of the elements
-  # will be preserved.
-  #
-  # @return [Array] +self+
-  def bubble_sort!(&block)
-    return self if length <= 1
-    n = length
-    loop do
-      new_n = bubble_sort_check(n, &block)
-      n = new_n
-      break if n.zero?
-    end
-    self
-  end
-
-  # Returns a new array created by sorting +self+ with bubble sort algorithm, using a set of keys generated by mapping
-  # the values in self through the given block.
-  #
-  # The result is guaranteed to be stable. When the comparison of two elements returns +0+, the order of the elements
-  # will be preserved.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  # @return [Array] if a block is given, the sorted array
-  # @return [Enumerator] if no block is given, an Enumerator
-  def bubble_sort_by(&block)
-    if block_given?
-      dup.bubble_sort_by!(&block)
-    else
-      to_enum :bubble_sort_by
-    end
-  end
-
-  # Sorts +self+ in place with bubble sort algorithm, using a set of keys generated by mapping the values in self
-  # through the given block.
-  #
-  # The result is guaranteed to be stable. When the comparison of two elements returns +0+, the order of the elements
-  # will be preserved.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  # @return [Array] if a block is given, the sorted array
-  # @return [Enumerator] if no block is given, an Enumerator
-  def bubble_sort_by!(&_block)
-    if block_given?
-      bubble_sort! do |a, b|
-        yield(a) <=> yield(b)
-      end
-    else
-      to_enum :bubble_sort_by!
-    end
-  end
-
-  private
-
-  # @private
-  def bubble_sort_check(length_checking, &block)
-    new_n = 0
-    (1...length_checking).each do |i|
-      next unless sort_compare(self[i - 1], self[i], &block).positive?
-      swap i - 1, i
-      new_n = i
-    end
-    new_n
-  end
-end

data/lib/array/sort/heap_sort.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-class Array
-  # Returns a new array created by sorting +self+, using heap sort algorithm.
-  #
-  # Comparisons for the sort will be done using the <=> operator or using an optional code block.
-  #
-  # The block must implement a comparison between +a+ and +b+ and return an integer less than 0 when +b+ follows +a+,
-  # +0+ when +a+ and +b+ are equivalent, or an integer greater than 0 when +a+ follows +b+.
-  #
-  # The result is not guaranteed to be stable. When the comparison of two elements returns +0+, the order of the
-  # elements is unpredictable.
-  #
-  # @return [Array] the sorted array
-  def heap_sort(&block)
-    dup.heap_sort!(&block)
-  end
-
-  # Sorts +self+ in place, using heap sort algorithm.
-  #
-  # Comparisons for the sort will be done using the <=> operator or using an optional code block.
-  #
-  # The block must implement a comparison between +a+ and +b+ and return an integer less than 0 when +b+ follows +a+,
-  # +0+ when +a+ and +b+ are equivalent, or an integer greater than 0 when +a+ follows +b+.
-  #
-  # The result is not guaranteed to be stable. When the comparison of two elements returns +0+, the order of the
-  # elements is unpredictable.
-  #
-  # @return [Array] +self+
-  def heap_sort!(&block)
-    return self if length <= 1
-    heapify(&block)
-    (length - 1).downto(1) do |end_|
-      swap(end_, 0)
-      sift_down(0, end_ - 1, &block)
-    end
-    self
-  end
-
-  # Returns a new array created by sorting +self+ with heap sort algorithm, using a set of keys generated by mapping the
-  # values in self through the given block.
-  #
-  # The result is not guaranteed to be stable. When the comparison of two elements returns +0+, the order of the
-  # elements is unpredictable.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  # @return [Array] if a block is given, the sorted array
-  # @return [Enumerator] if no block is given, an Enumerator
-  def heap_sort_by(&block)
-    if block_given?
-      dup.heap_sort_by!(&block)
-    else
-      to_enum :heap_sort_by
-    end
-  end
-
-  # Sorts +self+ in place with heap sort algorithm, using a set of keys generated by mapping the values in self through
-  # the given block.
-  #
-  # The result is not guaranteed to be stable. When the comparison of two elements returns +0+, the order of the
-  # elements is unpredictable.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  # @return [Array] if a block is given, the sorted array
-  # @return [Enumerator] if no block is given, an Enumerator
-  def heap_sort_by!(&_block)
-    if block_given?
-      heap_sort! do |a, b|
-        yield(a) <=> yield(b)
-      end
-    else
-      to_enum :heap_sort_by!
-    end
-  end
-
-  private
-
-  # @private
-  def heapify(&block)
-    end_ = length - 1
-    (length / 2 - 1).downto(0) do |start|
-      sift_down(start, end_, &block)
-    end
-  end
-
-  # @private
-  def sift_down(start, end_, &block)
-    root = start
-    loop do
-      child = root * 2 + 1
-      break if child > end_
-      child += 1 if check_less_than_sibling(child, end_, &block)
-      break if check_max_heap_order(root, child, &block)
-      root = child
-    end
-  end
-
-  # @private
-  def check_less_than_sibling(child, end_, &block)
-    child + 1 <= end_ && sort_compare(self[child], self[child + 1], &block) == -1
-  end
-
-  # @private
-  def check_max_heap_order(root, child, &block)
-    return true unless sort_compare(self[root], self[child], &block) == -1
-    swap root, child
-    false
-  end
-end

data/lib/array/sort/helper.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-class Array
-  # Swap two elements in the array, and returns +self+.
-  #
-  # @param index1 [Integer] The index of the first element.
-  # @param index2 [Integer] The index of the second element.
-  # @return [Array]
-  # @raise [ArgumentError] If either of the two parameters is not an Integer.
-  def swap(index1, index2)
-    raise ArgumentError, 'Index must be an integer.' unless index1.is_a?(Integer) && index2.is_a?(Integer)
-    self[index1], self[index2] = self[index2], self[index1] if index1 != index2
-    self
-  end
-
-  private
-
-  # Compare two elements.
-  #
-  # If a block is provided, it will be used to compare the two elements. If not, operator +<=>+ will be used.
-  def sort_compare(element1, element2, &_block)
-    if block_given?
-      yield element1, element2
-    else
-      element1 <=> element2
-    end
-  end
-
-  # Clear everything in +self+, and add all elements in +target+.
-  def become_clone_of(target)
-    clear
-    concat target
-  end
-end

data/lib/array/sort/insertion_sort.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-class Array
-  # Returns a new array created by sorting +self+, using insertion sort algorithm.
-  #
-  # Comparisons for the sort will be done using the <=> operator or using an optional code block.
-  #
-  # The block must implement a comparison between +a+ and +b+ and return an integer less than 0 when +b+ follows +a+,
-  # +0+ when +a+ and +b+ are equivalent, or an integer greater than 0 when +a+ follows +b+.
-  #
-  # The result is guaranteed to be stable. When the comparison of two elements returns +0+, the order of the elements
-  # will be preserved.
-  #
-  # @return [Array] the sorted array
-  def insertion_sort(&block)
-    dup.insertion_sort!(&block)
-  end
-
-  # Sorts +self+ in place, using insertion sort algorithm.
-  #
-  # Comparisons for the sort will be done using the <=> operator or using an optional code block.
-  #
-  # The block must implement a comparison between +a+ and +b+ and return an integer less than 0 when +b+ follows +a+,
-  # +0+ when +a+ and +b+ are equivalent, or an integer greater than 0 when +a+ follows +b+.
-  #
-  # The result is guaranteed to be stable. When the comparison of two elements returns +0+, the order of the elements
-  # will be preserved.
-  #
-  # @return [Array] +self+
-  def insertion_sort!(&block)
-    return self if length <= 1
-    (1...length).each do |i|
-      i.downto(1) do |j|
-        break unless sort_compare(self[j - 1], self[j], &block) == 1
-        swap(j - 1, j)
-      end
-    end
-    self
-  end
-
-  # Returns a new array created by sorting +self+ with insertion sort algorithm, using a set of keys generated by
-  # mapping the values in self through the given block.
-  #
-  # The result is guaranteed to be stable. When the comparison of two elements returns +0+, the order of the elements
-  # will be preserved.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  # @return [Array] if a block is given, the sorted array
-  # @return [Enumerator] if no block is given, an Enumerator
-  def insertion_sort_by(&block)
-    if block_given?
-      dup.insertion_sort_by!(&block)
-    else
-      to_enum :insertion_sort_by
-    end
-  end
-
-  # Sorts +self+ in place with insertion sort algorithm, using a set of keys generated by mapping the values in self
-  # through the given block.
-  #
-  # The result is guaranteed to be stable. When the comparison of two elements returns +0+, the order of the elements
-  # will be preserved.
-  #
-  # If no block is given, an Enumerator is returned instead.
-  #
-  # @return [Array] if a block is given, the sorted array
-  # @return [Enumerator] if no block is given, an Enumerator
-  def insertion_sort_by!(&_block)
-    if block_given?
-      insertion_sort! do |a, b|
-        yield(a) <=> yield(b)
-      end
-    else
-      to_enum :insertion_sort_by!
-    end
-  end
-end