expertsort 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in expertsort.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Ng Guoyou
+
+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,56 @@
+# EXPERTSORT
+
+Expertsort (stylised EXPERTSORT) is a collection of EXPERT PROGRAMMER sorting algorithms.
+
+Ever felt that sorting in Ruby is too fast?
+
+Need a slow algorithm for v0.0.1 of your application?
+
+Is your hardware too fast?
+
+Want to prove that sorting in Ruby is slow as balls?
+
+EXPERTSORT is here to help.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'expertsort'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install expertsort
+
+## Usage
+
+    [5, 4, 3, 1, 2].bogosort
+    => [1, 2, 3, 4, 5]
+
+## Sorts
+
+### Bogosort
+
+* `bogosort`, `bogosort!`
+
+### Stoogesort
+
+* `stoogesort`, `stoogesort!`
+
+### Slowestsort
+
+* `slowestsort`, `slowestsort!`
+
+### Sleepsort
+
+* `sleepsort`, `sleepsort!`
+
+Sleepsort raises a `RangeError` if the array contains a negative element.
+
+## Testing
+
+There is a rspec for EXPERTSORT at `spec/expertsort/expertsort_spec.rb`.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/expertsort.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "expertsort/version"
+
+Gem::Specification.new do |s|
+  s.name        = "expertsort"
+  s.version     = Expertsort::VERSION
+  s.authors     = ["Ng Guoyou"]
+  s.email       = ["fauxface+github@gmail.com"]
+  s.homepage    = "https://github.com/gyng/expertsort"
+  s.summary     = %q{A collection of EXPERT PROGRAMMER sorting algorithms.}
+  s.description = %q{Expertsort (stylised EXPERTSORT) is a collection of EXPERT PROGRAMMER sorting algorithms.
+                     Ever felt that sorting in Ruby is too fast?
+                     Need a slow algorithm for v0.0.1 of your application? (So you can show your boss that you, programmer extraordinaire, significantly improved performance in v0.0.2)
+                     Want to prove that sorting in Ruby is slow as balls?
+                     EXPERTSORT is here to help.}
+  s.license     = "MIT"
+
+  s.rubyforge_project = "expertsort"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/lib/expertsort.rb

@@ -0,0 +1,13 @@
+require "expertsort/version"
+
+require 'expertsort/sorts/bogosort'
+require 'expertsort/sorts/sleepsort'
+require 'expertsort/sorts/slowestsort'
+require 'expertsort/sorts/stoogesort'
+
+class Array
+  include Expertsort::BogoSort
+  include Expertsort::SleepSort
+  include Expertsort::SlowestSort
+  include Expertsort::StoogeSort
+end

data/lib/expertsort/sorts/bogosort.rb

@@ -0,0 +1,16 @@
+module Expertsort
+  module BogoSort
+    def bogosort
+      self.dup.bogosort!
+    end
+
+    def bogosort!
+      self.shuffle! while !sorted?
+      self
+    end
+
+    def sorted?
+      each_cons(2).all? { |a, b| (a <=> b) <= 0 }
+    end
+  end
+end

data/lib/expertsort/sorts/sleepsort.rb

@@ -0,0 +1,25 @@
+module Expertsort
+  module SleepSort
+    def sleepsort
+      sorted = []
+      threads = []
+      semaphore = Mutex.new
+
+      # Reduce potential impact of thread creation time by joining them when all threads have been created
+      self.each do |e|
+        raise RangeError, "Cannot sleep sort an array with negative elements: #{e}" if e.to_i < 0
+        threads << Thread.new do
+          sleep e.to_i
+          semaphore.synchronize { sorted << e.to_i }
+        end
+      end
+
+      threads.each { |t| t.join }
+      sorted
+    end
+
+    def sleepsort!
+      self.replace(sleepsort)
+    end
+  end
+end

data/lib/expertsort/sorts/slowestsort.rb

@@ -0,0 +1,12 @@
+module Expertsort
+  module SlowestSort
+    # 100% Genuine Python Snake Oil Quality Product
+    def slowestsort
+      self.dup.sort!
+    end
+
+    def slowestsort!
+      self.sort!
+    end
+  end
+end

data/lib/expertsort/sorts/stoogesort.rb

@@ -0,0 +1,23 @@
+module Expertsort
+  module StoogeSort
+    # Straight up reimplementation of the algorithm on Wikipedia.
+    def stoogesort
+      self.dup.stoogesort!
+    end
+
+    def stoogesort!(i = 0, j = self.length-1)
+      if self[j] < self[i]
+        self[i], self[j] = self[j], self[i]
+      end
+
+      if j - i + 1 >= 3
+        t = (j - i + 1) / 3
+        stoogesort!(i, j - t)
+        stoogesort!(i + t, j)
+        stoogesort!(i, j - t)
+      end
+
+      self
+    end
+  end
+end

data/lib/expertsort/version.rb

@@ -0,0 +1,3 @@
+module Expertsort
+  VERSION = "0.0.1"
+end

data/spec/expertsort/expertsort_spec.rb

@@ -0,0 +1,78 @@
+require 'expertsort'
+
+describe Array do
+  before do
+    @unsorted = [5, 4, 3, 1, 2]
+    @sorted = @unsorted.sort
+  end
+
+  describe 'BogoSort' do
+    it 'sorts' do
+      expect(@unsorted.bogosort).to eq(@sorted)
+    end
+
+    it 'has a destuctive method' do
+      array = @unsorted.dup
+      old_object_id = array.object_id
+      array.bogosort!
+      expect(old_object_id).to eq(array.object_id)
+    end
+  end
+
+  describe 'StoogeSort' do
+    it 'sorts' do
+      expect(@unsorted.stoogesort).to eq(@sorted)
+    end
+
+    it 'has a destuctive method' do
+      array = @unsorted.dup
+      old_object_id = array.object_id
+      array.stoogesort!
+      expect(old_object_id).to eq(array.object_id)
+    end
+  end
+
+  describe 'SleepSort' do
+    it 'sorts' do
+      expect(@unsorted.sleepsort).to eq(@sorted)
+    end
+
+    it 'has a destuctive method' do
+      array = @unsorted.dup
+      old_object_id = array.object_id
+      array.sleepsort!
+      expect(old_object_id).to eq(array.object_id)
+    end
+
+    it 'takes a long time' do
+      start_time = Time.now
+      @unsorted.sleepsort
+      expect(Time.now).to be > (start_time + @unsorted.max)
+    end
+
+    it 'raises an error if there is a negative element' do
+      bad_data = [1, 2, 0, -1, -2]
+      expect{bad_data.sleepsort}.to raise_error(RangeError, 'Cannot sleep sort an array with negative elements: -1')
+    end
+  end
+
+  describe 'SlowestSort' do
+    it 'sorts' do
+      expect(@unsorted.slowestsort).to eq(@sorted)
+    end
+
+    it 'has a destuctive method' do
+      array = @unsorted.dup
+      old_object_id = array.object_id
+      array.slowestsort!
+      expect(old_object_id).to eq(array.object_id)
+    end
+
+    it 'takes a very long time' do
+      start_time = Time.now
+      @unsorted.slowestsort
+      sleep(1)
+      expect(Time.now).to be > start_time + 1
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: expertsort
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ng Guoyou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &25494828 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *25494828
+description: ! "Expertsort (stylised EXPERTSORT) is a collection of EXPERT PROGRAMMER
+  sorting algorithms.\n                     Ever felt that sorting in Ruby is too
+  fast?\n                     Need a slow algorithm for v0.0.1 of your application?
+  (So you can show your boss that you, programmer extraordinaire, significantly improved
+  performance in v0.0.2)\n                     Want to prove that sorting in Ruby
+  is slow as balls?\n                     EXPERTSORT is here to help."
+email:
+- fauxface+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- expertsort.gemspec
+- lib/expertsort.rb
+- lib/expertsort/sorts/bogosort.rb
+- lib/expertsort/sorts/sleepsort.rb
+- lib/expertsort/sorts/slowestsort.rb
+- lib/expertsort/sorts/stoogesort.rb
+- lib/expertsort/version.rb
+- spec/expertsort/expertsort_spec.rb
+homepage: https://github.com/gyng/expertsort
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: expertsort
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: A collection of EXPERT PROGRAMMER sorting algorithms.
+test_files: []