sortviz 0.6.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ab0c658aff4dc772ecffcacb46cf611eabb3461
-  data.tar.gz: 22438a128feac8deb9c70aee7c33d580d5faed1b
+  metadata.gz: 970249e15c43b4ade3c5ea494b42c41105854a23
+  data.tar.gz: a85bbd678f174d5efc01da4fe8d432fbbc450922
 SHA512:
-  metadata.gz: 142a64eec59079b2e6e8af322a593226ebdbd04163b69f6f964b2bbe856db9a043626ea61e3d7761533afa833b1c300509983275f78416ad37a2ae98054fe880
-  data.tar.gz: 76f9fed39164fbad24c24cef1891095e581eb551b8c967dfff3ed7b5973c8b561912525f3836da19a65b0fe0fd5499967992a27403a71ae37205be3ffef419c7
+  metadata.gz: 7d1545bfa711f394446dba788a9784bb045e01689f74906944e08c9d506b97afd9c69a37cf8e4629edc9c7afa9dc221a2f9a67c6c8803dce6d869f220d828167
+  data.tar.gz: 3c2b5d78bad824b5926debf84533a1b5fa9dcd6cbb23fddbd6738b13fec39bd11bcb46d96040e4baf51b08feba355313b1d47a466ec136546498acf97fb190ff

data/README.md

@@ -4,30 +4,13 @@ Sortviz is a small terminal program written in Ruby and uses the Curses library
 It lets you visualize sorting algorithms, you can add more sorting algorithms
 at will but for the time being it can only load the ones bundled with itself.
 
-For pointers on the over simplified (Quite bad too) plugin system, check 
-[lib/sortviz/plugins.rb](lib/sortviz/plugins.rb) and check the plugins at
-[lib/algorithms](lib/algorithms).
+However, for pointers about writing plugins, check 
+[lib/algorithms](lib/algorithms) and check the plugin system at
+[lib/sortviz/algorithms.rb](lib/sortviz/algorithms.rb).
 
 ## Looks like this
 ![Screenshot][screenshot]
 
-## Working with Sortviz
-
-Some sorting algorithms operate on single lists, swapping and sifting through
-them. Others operate on multiple lists, like merge sort. With any luck, you
-might be able to get these kind of sorting algorithms working but until I officially test against them, you're on your own.
-
-__Generally speaking, the sorting algorithm (your code) has to yield a partially sorted list, with a current index on *every iteration*__.
-
-For examples, check the [lib/algorithms](lib/algorithms) directory. 
-
-Some implementations like the bubble sort one at [lib/algorithms/bubblesort.rb](lib/algorithms/bubblesort.rb) generate some visual artifacts. 
-If you look at it, you'd notice that the index we're yielding is +1.
-
-The reason for that is because otherwise, Sortviz will be selecting a column
-that might in fact be the real current index, but the actual swapping is happening a column + 1. Which becomes confusing, so we +1 to select the
-actual column that's moving around.
-
 ## Installation
 
 This gem is not intended for your application's Gemfile, it's a
@@ -40,10 +23,9 @@ install it as:
 ## Usage
 
 ```shell
-$ sortviz -h      # Will display help
-$ sortviz -l      # Will give you a list of available sorting algorithms
-$ sortviz -s ALGO # Will start visualizing the sorting of 20 digits using that algorithm
+$ sortviz -h
 ```
+
 ## Development
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
@@ -57,18 +39,8 @@ And don't make me do your job for you. It's OSS, be reasonable.
 
 ## Why
 
-Because I'm a terminal guy that's why. I like to think I'm not too
-bad googling either and for the life of me I couldn't find anything similar
-when a buddy of mine that teaches CS at a university was like, I need a terminal based sorting visualizer. I'm like PSH! Like there has to be some out there, lo-and-behold, they're all web and javascript based.
-
-I'm also using this as a demo for an interview, hope it works out. They asked
-for code I'm most proud of, pretty hard question to find an answer to, as it turns out.
-It's not like I write code I'm not generally proud of but yeah, was a real
-bummer looking over everything I worked in, so this is my solution.
-
-Am I proud of it? Well yes, could be way better but I'm pressed on time.
-
-*I also realized the notion of being proud of something is more of a process, after you've invested time and effort into something and grew it, you can't help but feel proud of it.*
+I blogged about this here:
+[Software, a labor of love](http://hadyahmed.com/2016/06/software-a-labor-of-love/)
 
 ## Future
 

data/exe/sortviz

@@ -10,37 +10,58 @@
 require 'optparse'
 require "sortviz"
 
-options = {}
+Options = Struct.new(:algorithm, :speed, :path)
+args = Options.new(:'bubble-sort', 0.05)
 
-oparser = OptionParser.new do |opts|
-  opts.banner = <<-HELP
-USAGE: sortviz [options]
+@parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: sortviz [options] sorting_algorithm_name'
 
-Exit: Use 'q' to exit during visualization
-
-  HELP
-
-  opts.on('-s', '--sort ALGORITHM', 'Visualize sorting ALGORITHM (Default: bubblesort)') do |algo|
-    if Sortviz::ALGORITHMS.has_key? algo.to_sym
-      Sortviz.init(algo.to_sym)
-    else
-      puts "We couldn't find this algorithm, please check available algorithms through -l option"
-      exit
-    end
+  opts.on('-sSPEED', '--sorting-speed=SPEED', OptionParser::DecimalNumeric, 'Set the sorting speed in seconds') do |speed|
+    args.speed = speed
   end
 
   opts.on('-l', '--list', 'List of available sorting algorithms') do
     puts "Sortviz: List of available algorithms"
     puts "-------------------------------------"
-    Sortviz::ALGORITHMS.each do |func_name, name|
-      puts "  #{name} (-s #{func_name})"
+    Sortviz::Algorithms.plugins.each do |plugin|
+      print "#{plugin[:display_name]} \n"
+      print "\t Use as: sortviz #{plugin[:name]} \n"
+      print "\t Author: #{plugin[:author]} \n"
     end
+    exit
   end
 
-  opts.on('-h', '--help', 'View this help') do
+  opts.on_tail('-h', '--help', 'Show this message') do
     puts opts
     exit
   end
+
+  opts.on_tail('--version', 'Show version') do
+    puts "Sortviz v#{Sortviz::VERSION}"
+    exit
+  end
 end
 
-oparser.parse!(ARGV)
+def show_help(message = nil)
+  print "#{message} \n\n" unless message.nil?
+  puts @parser
+  exit -1
+end
+
+if ARGV.empty?
+  show_help
+else
+  begin
+    @parser.parse!(ARGV)
+  rescue OptionParser::MissingArgument => missing
+    print "Error: #{missing.to_s} \n\n"
+    show_help
+  end
+
+  algorithm = Sortviz.find_algorithm(ARGV.pop)
+  show_help("Error: Please specify the algorithm name") if algorithm.nil?
+
+  args.algorithm = algorithm
+
+  Sortviz.init(args)
+end

data/lib/algorithms/bubblesort.rb

@@ -1,15 +1,16 @@
-module Sortviz
-  
-  def bubblesort(list)
-    list.each_index do |i|
-      (list.length - i - 1).times do |j|
-        if list[j] > list[j + 1]
-          list[j], list[j + 1] = list[j + 1], list[j]
+Sortviz::Algorithms.define 'Bubble Sort' do
+  author 'ieatkimchi'
+  url 'https://github.com/ieatkimchi/Bubble_Sort_Ruby'
+  name :'bubble-sort'
+
+  sort -> (unsorted_list){
+    unsorted_list.each_index do |i|
+      (unsorted_list.length - i - 1).times do |j|
+        if unsorted_list[j] > unsorted_list[j + 1]
+          unsorted_list.swap!(j, j+1)
         end
-        yield list, j + 1
       end
     end
-  end
-
-  define_algorithm "Bubble Sort", :bubblesort
+    return unsorted_list
+  }
 end

data/lib/algorithms/insertionsort.rb

@@ -1,16 +1,16 @@
-module Sortviz
-  # insertion_sort is brought in from
-  # https://coderwall.com/p/z8vowg/simple-sorting-algorithms-with-ruby  
-  def insertionsort(list)
-    (1...list.size).each do |i|
+Sortviz::Algorithms.define 'Insertion Sort' do
+  author 'Emad Elsaid'
+  url 'https://coderwall.com/p/z8vowg/simple-sorting-algorithms-with-ruby'
+  name :'insertion-sort'
+
+  sort -> (unsorted_list) {
+    (1...unsorted_list.size).each do |i|
       j = i
-      while j > 0 and list[j-1] > list[j]
-        list[j], list[j-1] = list[j-1], list[j]
+      while j > 0 and unsorted_list[j-1] > unsorted_list[j]
+        unsorted_list.swap!(j, j-1)
         j = j - 1
-        yield list, j
       end
     end
-  end
-
-  define_algorithm "Insertion Sort", :insertionsort
+    return unsorted_list
+  }
 end

data/lib/algorithms/selectionsort.rb

@@ -1,19 +1,18 @@
-module Sortviz
-  # selection_sort is brought in from
-  # https://coderwall.com/p/z8vowg/simple-sorting-algorithms-with-ruby
-  def selectionsort(list)
-    (0...list.size).each do |j|
+Sortviz::Algorithms.define 'Selection Sort' do
+  author 'Emad Elsaid'
+  url 'https://coderwall.com/p/z8vowg/simple-sorting-algorithms-with-ruby'
+  name :'selection-sort'
+
+  sort -> (unsorted_list) {
+    (0...unsorted_list.size).each do |j|
       # find index of minimum element in the unsorted part 
       iMin = j
-      (j+1...list.size).each do |i|
-        iMin = i if list[i] < list[iMin]
+      (j+1...unsorted_list.size).each do |i|
+        iMin = i if unsorted_list[i] < unsorted_list[iMin]
       end
-
       # then swap it
-      list[j], list[iMin] = list[iMin], list[j]
-      yield list, j
+      unsorted_list.swap!(j, iMin)
     end
-  end
-
-  define_algorithm "Selection Sort", :selectionsort
+    return unsorted_list
+  }
 end

data/lib/sortviz.rb

@@ -1,18 +1,25 @@
 require 'curses'
 require 'forwardable'
 require 'sortviz/version'
+require 'sortviz/core_ext'
 require 'sortviz/cursor'
 require 'sortviz/canvas'
 require 'sortviz/visualizer'
-require 'sortviz/plugins'
+require 'sortviz/algorithms'
 
 libdir = File.dirname(__FILE__) 
 Dir[libdir + '/algorithms/*.rb'].each {|file| require file }
 
 module Sortviz
   extend self
-  def init(algo)
-    visualizer = Visualizer.new algo
+
+  def find_algorithm(algorithm)
+    return nil if algorithm.nil?
+    Algorithms.plugins.find { |plugin| plugin[:name] == algorithm.to_sym }.freeze
+  end
+
+  def init(args)
+    visualizer = Visualizer.new args
     visualizer.visualize
   end
 end

data/lib/sortviz/algorithms.rb

@@ -0,0 +1,30 @@
+module Sortviz
+  class Algorithms
+    class << self
+      def define(algorithm_name, &block)
+        plugins << { display_name: algorithm_name }
+        instance_eval &block
+      end
+
+      def plugins
+        @plugins ||= []
+      end
+      
+      def sort(block)
+        Algorithms.plugins.last[:sort] = block
+      end
+
+      def name(name)
+        plugins.last[:name] = name
+      end
+
+      def author(author)
+        plugins.last[:author] = author
+      end
+
+      def url(link)
+        plugins.last[:url] = link
+      end
+    end
+  end
+end

data/lib/sortviz/canvas.rb

@@ -25,45 +25,60 @@ module Sortviz
         @screen_dim[:lines] - MARGIN, 
         @screen_dim[:cols] - MARGIN,
         @cursor.y, @cursor.x)
-      @window.box('|', '-')
       @window.nodelay = 1 # Non-blocking mode for #getch
     end
 
     # Draws the partially sorted list and highlights the current index
     # It also attempts to center the graph in the display area, does well but
     # not always, sometimes it'll be shifted to the right a bit.
-    def redraw(partially_sorted, selected_indx)
-      @window.clear
-      @window.box('|', '-')
-      
-      @cursor.move(0, 0)
-      @cursor.tprint("Algorithm: #{@title}")
+    def draw(partially_sorted, selection)
+      clear
+      draw_title
 
       len = partially_sorted.join.center(4).length
+      # We draw bottom up, this sets our y-position at the very bottom of
+      # the canvas and our x-position half way through the canvas
       @cursor.move(@window.maxy - 1, (@window.maxx - len) / MARGIN)
       
       partially_sorted.each_with_index do |number, i|
-        @cursor.tprint(("|%02d|" % number))
+        draw_number(number)
+        draw_bar(number, i == selection)
+        next_bar
+      end
+      
+      Curses.doupdate
+    end
 
-        @cursor.decr_y
+    private
 
-        draw_bar(number, selected_indx == i)
+    def clear
+      @window.clear
+      @window.box('|', '-')
+    end
 
-        @cursor.move_y(@window.maxy - 1)
-        @cursor.incr_x MARGIN
-      end
+    def draw_title
+      @cursor.move(0, 0)
+      @cursor.tprint("Algorithm: #{@title}")
     end
 
-    private
+    def draw_number(number)
+      @cursor.tprint(("|%02d|" % number))
+      @cursor.decr_y
+    end
 
     def draw_bar(height, highlighted)
       attr = highlighted ? @red_highlight : Curses::A_REVERSE
       attron(attr)
       height.times do
-        @window.addstr(" ".center(4)) # 4 spaces
+        @cursor.tprint(" ".center(4)) # 4 spaces
         @cursor.decr_y
       end
       attroff(attr)
     end
+
+    def next_bar
+      @cursor.move_y(@window.maxy - 1)
+      @cursor.incr_x MARGIN
+    end
   end
 end

data/lib/sortviz/core_ext.rb

@@ -0,0 +1,17 @@
+# TODO: Use refinements
+class Array
+  def versions
+    @versions ||= Array.new
+  end
+
+  def swap!(a, b)
+    self[a], self[b] = self[b], self[a]
+    mark_version(b)
+  end
+
+  private
+  # idx: Current selection index
+  def mark_version(idx)
+    versions << [self.dup, idx]
+  end
+end

data/lib/sortviz/version.rb

@@ -1,3 +1,3 @@
 module Sortviz
-  VERSION = "0.6.1"
+  VERSION = "0.8.0"
 end

data/lib/sortviz/visualizer.rb

@@ -13,20 +13,22 @@ module Sortviz
   class Visualizer
     # Origin starts at (1, 0) not (0, 0)
     ORIGIN = { y: 1, x: 5 }
-    SLEEP_INTERVAL = 0.05
 
     # Initializes a new Visualizer for a sorting algorithm
     #
     # Params:
-    # +algo+:: <tt>Symbol</tt> A symbol representing a sorting algorithm method
-    def initialize(algo)
+    # +args+:: <tt>Struct</tt> Command line args that configure how visualization will happen
+    def initialize(args)
       setup_curses
       @screen_dim = { cols: Curses.cols - ORIGIN[:x], lines: Curses.lines }
       @screen     = Curses.stdscr
       @cursor     = Cursor.new(@screen, ORIGIN)
-      @canvas     = Canvas.new(ALGORITHMS[algo], @cursor, @screen_dim)
 
-      @algo       = algo
+      @algorithm  = args.algorithm
+
+      @canvas     = Canvas.new(@algorithm[:display_name], @cursor, @screen_dim)
+
+      @sorting_speed = args.speed
       @unsorted_list = generate_list
     end
 
@@ -69,13 +71,13 @@ module Sortviz
         
         @cursor.switch_window @canvas.window
 
-        loop do
-           Sortviz.send(@algo, @unsorted_list) do |partially_sorted, selected_indx|
-            @canvas.redraw(partially_sorted, selected_indx)
-            Curses.doupdate
-            sleep SLEEP_INTERVAL
+        while true do
+          result = @algorithm[:sort].call(@unsorted_list)
+          result.versions.each do |version|
+            @canvas.draw(version[0], version[1])
+            sleep @sorting_speed
             return if @canvas.getch
-           end
+          end
           @cursor.switch_window @screen # Switch back to our stdscr
           @cursor.restore # Restoring here, would place us right under the canvas box
           @cursor.newline

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sortviz
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Hady Ahmed
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-20 00:00:00.000000000 Z
+date: 2016-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,9 +91,10 @@ files:
 - lib/algorithms/insertionsort.rb
 - lib/algorithms/selectionsort.rb
 - lib/sortviz.rb
+- lib/sortviz/algorithms.rb
 - lib/sortviz/canvas.rb
+- lib/sortviz/core_ext.rb
 - lib/sortviz/cursor.rb
-- lib/sortviz/plugins.rb
 - lib/sortviz/version.rb
 - lib/sortviz/visualizer.rb
 - screenshot.png

data/lib/sortviz/plugins.rb

@@ -1,21 +0,0 @@
-module Sortviz
-  extend self
-  ALGORITHMS = {}
-
-  # Defines a new algorithm for sorting by adding some meta data to
-  # <tt>Sortviz::ALGORITHMS</tt> and turning the sorting algorithm method into a
-  # Module function of <tt>Sortviz</tt>.
-  #
-  # It's a bad design, should be fixed soon with a proper plugin system as this
-  # way pollutes the Sortviz namespace.
-  #
-  # Params:
-  # +name+:: <tt>String</tt> Name of the sorting algorithm for display purposes
-  # +func_name+:: <tt>Symbol</tt> A symbol representation of the actual method that does
-  # the actual sorting. It's important that both match or else <tt>Sortviz::Visualizer</tt>
-  # will not be able to find it and call it.
-  def define_algorithm(name, func_name)
-    ALGORITHMS[func_name] = name
-    module_function func_name
-  end
-end