dekernel 0.0.0

data/bin/dekernel

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+$options = { dry_run: false, assume_yes: false, kernels_list: nil,
+             all_except: nil, no_confirm: false }
+OptionParser.new { |opts|
+  opts.banner = "Usage: ./deKernelScript [--dry-run, --assume-yes, --kernels-list=[space separated kernel #'s]"
+
+  opts.on('-s', '--dry-run',      'Dry run with apt-get')     do
+    $options[:dry_run] = true
+  end
+  opts.on('-y', '--assume-yes',   'Assume yes with apt-get')  do
+    $options[:assume_yes] = true
+  end
+  opts.on('-n', '--no-confirm',   "Do not confirm with 'Are you sure?' message")  do
+    $options[:no_confirm] = true
+  end
+  opts.on('-x', '--all-except', 'Remove all except the lastest (n) kernels', '=MANDATORY', Integer)   do |v|
+    $options[:all_except] = v.to_i
+  end
+  opts.on('-k', '--kernels-list', 'Kernels to remove list', '=MANDATORY')   do |v|
+    $options[:kernels_list] = v
+  end
+}.parse!
+
+require 'dekernel'
+
+DeKernel.run

data/lib/dekernel.rb

@@ -0,0 +1,24 @@
+class DeKernel
+  require 'dekernel/cernel'
+  require 'dekernel/message'
+
+  def self.run
+    original_free_space = Cernel.get_free_disk_space
+    Kernel.system "clear"
+    if $options[:dry_run]
+      $stdout.puts "\n" + "      THIS IS A DRY-RUN!, apt-get will only pretend." + "\n" + "\n"
+    end
+    $stdout.puts  "It's generally recommended to leave at least " +
+                  "three of your latest kernels installed." + "\n" + "\n"
+    if $options[:all_except] != nil
+      Cernel.purge_packages_from_a_list_of_kernels(Cernel.find_all_except_latest($options[:all_except]))
+    elsif $options[:kernels_list] != nil
+      Cernel.purge_packages_from_a_list_of_kernels(Cernel.safe_ified_kernels_list)
+    else
+      Cernel.purge_packages_from_a_list_of_kernels(Cernel.ask_which_to_remove)
+    end
+  ensure
+    $stdout.puts Message.other_kernels
+    $stdout.puts "#{Cernel.get_free_disk_space - original_free_space} megabytes of disk space were freed."
+  end
+end

data/lib/dekernel/cernel.rb

@@ -0,0 +1,104 @@
+class Cernel
+  class << self
+    def find_kernels
+      all_kernels = find_all_kernels
+      installed_kernels = find_installed_kernels(all_kernels)
+      { all: all_kernels, installed: installed_kernels }
+    end
+
+    def ask_which_to_remove
+      installed_kernels = find_kernels[:installed]
+      $stdout.puts Message.installed_kernels(installed_kernels)
+      Kernel.exit if installed_kernels.length == 0
+      kernels_to_remove = create_kernels_to_remove_list(installed_kernels)
+    end
+
+    def purge_packages_from_a_list_of_kernels(kernels_to_remove)
+      ($stderr.puts "\n" + "No kernels selected!" ; Kernel.exit) unless kernels_to_remove.length > 0
+      confirm_removals(kernels_to_remove) unless $options[:no_confirm]
+      packages_list = find_kernel_packages(kernels_to_remove)
+      IO.send(:popen, "sudo apt-get purge #{apt_options} #{packages_list.join("\s")} 1>&2") { |p| p.each { |f| $stdout.puts f } }
+      if $?.exitstatus != 0
+        $stdout.puts Message.purge_packages_failure($?)
+      else
+        $stdout.puts Message.purge_packages_success(kernels_to_remove)
+        Kernel.system "sudo apt-get clean" unless $options[:dry_run]
+      end
+    end
+
+    def get_free_disk_space
+      Kernel.send(:`, "df -BM /boot").split[10].to_i
+    end
+
+    def find_all_except_latest(number)
+      kernels = find_kernels
+      sort_properly(kernels[:installed]).rotate(-number).drop(number)
+    end
+
+    def safe_ified_kernels_list
+      options = $options[:kernels_list].split(" ").reject { |kernel| kernel =~ (/[a-z]/i) }
+      options = options.reject { |kernel| kernel =~ (/[0-9]{3,}/i) }
+      options.select { |kernel| kernel =~ kernel_regex }
+    end
+
+
+    private
+    def find_all_kernels
+      Kernel.send(:`, "ls /boot").each_line.grep(/vmlinuz/).collect { |l|
+        l.match(kernel_regex).to_s
+      }
+    end
+
+    def kernel_regex
+      /[0-9]\.[0-9]{1,2}\.[0-9]{1,2}-[0-9]{1,2}/
+    end
+
+    def find_installed_kernels(all_kernels)
+      all_kernels.select { |kernel|
+        Kernel.send(:system, "dpkg-query -f '${Package}\n' -W *#{kernel}* >/dev/null 2>&1")
+      }
+    end
+
+    def create_kernels_to_remove_list(installed_kernels)
+      installed_kernels.select { |kernel|
+        $stdout.print "Do you want to remove the #{kernel} kernel [y/N/yes/NO/?]"
+        next unless !!ARGF.first.strip.match(/^y$|^yes$/i)
+        $stdout.puts "Marking #{kernel} for removal" ; true
+      }
+    end
+
+    def find_kernel_packages(kernels_to_remove)
+      packages = kernels_to_remove.map { |kernel|
+        Kernel.send(:`, "dpkg-query -f '${Package}\n' -W *#{kernel}*").split("\n")
+      }.flatten
+      if packages.empty?
+        $stderr.puts "ERROR: No packages to remove." ; Kernel.exit
+      else
+        $stdout.puts "Packages are being uninstalled, please stand by..."
+      end ; packages
+    end
+
+    def confirm_removals(kernels_to_remove)
+      all_kernels = find_kernels
+      installed_kernels = all_kernels[:installed]
+      Kernel.system "clear"
+      $stdout.puts Message.ask_to_confirm_kernels_to_remove(kernels_to_remove, installed_kernels)
+      ($stderr.puts "Canceled!" ; Kernel.exit) unless !!ARGF.first.strip.match(/^y$|^yes$/i)
+      kernels_to_remove
+    end
+
+    def sort_properly(kernels)
+      kernels.sort_by { |kernel_string|
+        split = kernel_string.split(/-/)
+        [split[0], "%02d" % split[1]].join('-')
+      }
+    end
+
+    def apt_options
+      { y: $options[:assume_yes], s: $options[:dry_run] }.collect { |k, v|
+        if v == true ; "-#{k}" ; end
+      }.join(' ').strip
+    end
+  end
+end
+

data/lib/dekernel/message.rb

@@ -0,0 +1,74 @@
+class Message
+  class << self
+    ## Every method in this class returns a String object
+
+    def installed_kernels(installed_kernels)
+      [kernel_count(installed_kernels),
+      (installed_kernels.collect { |k| "  #{k}  " })].flatten.push("", "").join("\n")
+    end
+
+    def other_kernels
+      kernels = Cernel.find_kernels
+      if (kernels[:all] - kernels[:installed]).length > 0
+        ["",
+         "### NOTE: You have kernels in your /boot directory " +
+         "that have no corresponding packages installed.",
+         "###       If you know you don't want those kernels, " +
+         "you may want to remove them.",
+         "###       You can list and remove them with the following commands:",
+         list_and_remove_commands(kernels[:all] - kernels[:installed]),
+         "", ""].join("\n")
+      end or String.new
+    end
+
+    [:success, :failure].each { |exit_status|
+      define_method "purge_packages_#{exit_status}" do |message|
+        if exit_status == :success
+          ["",
+           "Successfully removed the kernel packages for: #{message.join(', ')}",
+           "",
+           "### NOTE: Usually apt-get will update your bootloader automatically,",
+           "###       but if you have any trouble you may need to update it manually.",
+           "###       (i.e. `sudo update-grub2` if you are using grub2)"]
+        else
+          ["", "ERROR: apt-get purge failed with \"#{message}\""]
+        end.join("\n")
+      end
+    }
+
+    def ask_to_confirm_kernels_to_remove(kernels_to_remove, installed_kernels)
+      header_message = kernels_to_remove.length > 1 \
+        ?  "The #{kernels_to_remove.length} kernels marked with asterisks will be apt-get purged:" \
+        :  "The kernel marked with asterisks will be apt-get purged:"
+      marked_up_kernels_list = installed_kernels.collect { |kernel|
+        kernels_to_remove.include?(kernel) ? "**#{kernel}**" : "  #{kernel}  "
+      }
+      [header_message, marked_up_kernels_list, "",
+       "Are you sure you want to continue [y/N/yes/NO/?]"].join("\n")
+    end
+
+    private
+    { "list" => "ls -ahl", "remove" => "rm -f  " }.each { |name, command|
+      define_method "#{name}_command" do |other_kernels|
+        command = other_kernels.collect { |kernel| "sudo #{command} /boot/*-#{kernel}*" }.join(" && ")
+        "###       `%s`" % command
+      end
+    }
+
+    def list_and_remove_commands(other_kernels)
+      [list_command(other_kernels), remove_command(other_kernels)].join("\n")
+    end
+
+    def kernel_count(installed_kernels)
+      case installed_kernels.length
+      when 0
+        "ERROR: No kernels found in the /boot directory!"
+      when 1
+        "Only one kernel found!"
+      when 2..(1.0/0.0)
+        "Found #{installed_kernels.length} kernels installed:"
+      end
+    end
+  end
+end
+

data/spec/lib/dekernel/cernel_spec.rb

@@ -0,0 +1,284 @@
+require 'spec_helper'
+
+describe 'Cernel' do
+  before :each do
+    $stdout.stub!(:puts)
+    $stdout.stub!(:print)
+    $stderr.stub!(:puts)
+    Kernel.stub!(:system)
+  end
+  context "#find_kernels" do
+    it "finds all kernels" do
+      Cernel.stub!(:find_all_kernels).and_return(@all_kernels)
+      kernels = Cernel.find_kernels
+      expect(kernels[:all]).to eq @all_kernels
+    end
+
+    it "finds installed kernels" do
+      Cernel.stub!(:find_installed_kernels).and_return(@installed_kernels)
+      kernels = Cernel.find_kernels
+      expect(kernels[:installed]).to eq @installed_kernels
+    end
+  end
+
+  context "#ask_which_to_remove" do
+    it "raises SystemExit if installed_kernels.length == 0" do
+      Cernel.stub!(:find_kernels).and_return({ installed: [] })
+      expect(lambda { Cernel.ask_which_to_remove }).to raise_error SystemExit
+    end
+
+    it "prints each one and adds to list" do
+      Cernel.stub!(:find_installed_kernels).and_return(@installed_kernels)
+      ARGF.stub!(:first).and_return("y", "n", "y")
+
+      expect(Cernel.ask_which_to_remove.to_s).to match(/#{@remove_kernels.to_s}/)
+    end
+
+    it "calls 'Message.installed_kernels(installed_kernels)'" do
+      Kernel.stub!(:exit)
+      Cernel.stub!(:find_kernels).and_return(@kernels_hash)
+      Message.should_receive(:installed_kernels).with(@installed_kernels)
+      ARGF.stub!(:first).and_return("y")
+
+      Cernel.ask_which_to_remove
+    end
+  end
+
+  context "#purge_packages_from_a_list_of_kernels(kernels_to_remove)" do
+    before :each do
+      IO.stub!(:popen)
+      Message.stub!(:purge_packages_success)
+      Message.stub!(:purge_packages_failure)
+    end
+
+    it "calls confirm_removals with $options[:no_confirm] = false (default)" do
+      Cernel.stub!(:find_kernel_packages).and_return(@remove_packages)
+      Cernel.should_receive(:confirm_removals).with(@remove_kernels)
+
+      Cernel.purge_packages_from_a_list_of_kernels(@remove_kernels)
+    end
+
+    it "does not call confirm_removals with $options[:no_confirm] = true" do
+      $options[:no_confirm] = true
+      Cernel.stub!(:find_kernel_packages).and_return(@remove_packages)
+      Cernel.should_not_receive(:confirm_removals).with(@remove_kernels)
+
+      Cernel.purge_packages_from_a_list_of_kernels(@remove_kernels)
+    end
+
+    context "when kernels_to_remove.length is 0" do
+      it "raises SystemExit" do
+        expect(lambda do
+          Cernel.purge_packages_from_a_list_of_kernels([])
+        end).to raise_error SystemExit
+      end
+
+      it "prints 'no kernels selected' message" do
+        Kernel.stub!(:exit)
+        $stderr.should_receive(:puts).with("\nNo kernels selected!")
+
+        Cernel.purge_packages_from_a_list_of_kernels([])
+      end
+    end
+
+
+    it "prints 'no packages error' message" do
+      Kernel.stub!(:exit)
+      $stderr.should_receive(:puts).with("ERROR: No packages to remove.")
+      Cernel.purge_packages_from_a_list_of_kernels([])
+    end
+
+    context "when kernels_to_remove.length is > 0" do
+      context "when packages found" do
+        before :each do
+          Cernel.stub!(:confirm_removals).and_return(@remove_kernels)
+        end
+
+        it "prints 'packages being uninstalled' message" do
+          Kernel.stub!(:`).with("dpkg-query -f '${Package}\n' -W *#{@installed_kernels.first}*").
+            and_return("package1 package2")
+          $stdout.should_receive(:puts).with("Packages are being uninstalled, please stand by...")
+
+          Cernel.purge_packages_from_a_list_of_kernels(@installed_kernels.first(1))
+        end
+
+        it "runs `apt-get purge` command with no options" do
+          IO.should_receive(:popen).with("sudo apt-get purge  package1 package2 1>&2")
+          Cernel.stub!(:find_kernel_packages).and_return(["package1", "package2"])
+
+          Cernel.purge_packages_from_a_list_of_kernels(@installed_kernels.first(1))
+        end
+
+        it "does not run 'apt-get clean' command if $options[:dry_run] == true" do
+          $options[:dry_run] = true
+          $?.stub!(:exitstatus).and_return(0)
+          IO.should_receive(:popen).with("sudo apt-get purge -s package1 package2 1>&2")
+          Cernel.stub!(:find_kernel_packages).and_return(["package1", "package2"])
+          Kernel.should_not_receive(:system).with("sudo apt-get clean")
+
+          Cernel.purge_packages_from_a_list_of_kernels(@installed_kernels.first(1))
+        end
+      end
+    end
+  end
+
+  context "#get_free_disk_space" do
+    it "gets available disk space" do
+      Kernel.should_receive(:`).with("df -BM /boot").
+        and_return("Filesystem     1M-blocks  Used Available Use% Mounted on\n/dev/sdc3         46935M 9115M    35437M  21% /\n")
+
+      Cernel.get_free_disk_space
+    end
+  end
+
+  context "#find_all_except_latest(number)" do
+    it "should find all except latest (number) kernels" do
+      Cernel.stub!(:find_kernels).and_return(@kernels_hash)
+      expect(Cernel.send(:find_all_except_latest, 1)).to eq @all_except_latest_one
+    end
+  end
+
+
+  ### private methods, test them or not?
+
+  context "#find_all_kernels" do
+    before :each do
+      Kernel.should_receive(:`).with("ls /boot").
+        and_return("vmlinuz-2.28.10-38-generic\nvmlinuz-3.2.0-39-generic\nvmlinuz-3.2.0-40-generic\n")
+    end
+
+    it "returns an array" do
+      expect(Cernel.send(:find_all_kernels)).to be_a_kind_of(Array)
+    end
+
+    it "returns greped kernel numbers" do
+      expect(Cernel.send(:find_all_kernels)).to eq ["2.28.10-38", "3.2.0-39", "3.2.0-40"]
+    end
+  end
+
+  context "#find_installed_kernels(all_kernels)" do
+    it "returns an array" do
+      expect(Cernel.send(:find_installed_kernels, @all_kernels)).to be_a_kind_of(Array)
+    end
+
+    it "calls dpkg command for each kernel" do
+      @all_kernels.each do |kernel|
+        Kernel.stub!(:`).with("dpkg-query -f '${Package}\n' -W *#{kernel}* >/dev/null 2>&1")
+        Kernel.should_receive(:system).with("dpkg-query -f '${Package}\n' -W *#{kernel}* >/dev/null 2>&1").
+          and_return("linux-headers-#{kernel}\nlinux-headers-#{kernel}-generic\nlinux-image-#{kernel}-generic\n")
+      end
+      Cernel.send(:find_installed_kernels, @all_kernels)
+    end
+
+    it "returns only kernels that have installed packages" do
+      { "true" => @installed_kernels, "false" => @other_kernels }.each do |value, kernels|
+        kernels.each do |kernel|
+          Kernel.stub!(:system).
+            with("dpkg-query -f '${Package}\n' -W *#{kernel}* >/dev/null 2>&1").
+              and_return(!!value.match(/true/))
+        end
+      end
+      expect(Cernel.send(:find_installed_kernels, @all_kernels)).to eq @installed_kernels
+    end
+  end
+
+  context "#create_kernels_to_remove_list(installed_kernels)" do
+    it "returns an array" do
+      ARGF.should_receive(:first).exactly(@installed_kernels.length).times.and_return('yes')
+      expect(Cernel.send(:create_kernels_to_remove_list, @installed_kernels)).to be_a_kind_of(Array)
+    end
+    
+    it "returns only the kernels selected" do
+      ARGF.should_receive(:first).exactly(@installed_kernels.length).times.and_return('yes', 'no', 'no')
+      expect(Cernel.send(:create_kernels_to_remove_list, @installed_kernels)).to eq @installed_kernels.first(1)
+    end
+  end
+
+  context "#find_kernel_packages(kernels_to_remove)" do
+    before :each do
+      @remove_kernels.each do |kernel|
+        Kernel.should_receive(:`).exactly(1).times.with("dpkg-query -f '${Package}\n' -W *#{kernel}*").
+          and_return(@remove_packages.join("\n"))
+      end
+      (@all_kernels - @remove_kernels).each do |kernel|
+        Kernel.should_not_receive(:system).with("dpkg-query -f '${Package}\n' -W *#{kernel}*")
+      end
+    end
+
+    it "returns an array" do
+      expect(Cernel.send(:find_kernel_packages, @remove_kernels)).to be_a_kind_of(Array)
+    end
+
+    it "returns only packages from the kernels_to_remove" do
+      # why do i have to use 'uniq' right here? without 'uniq' it returns a doubled array.
+      #expect(Cernel.send(:find_kernel_packages, @remove_kernels)).to eq @remove_packages
+      expect(Cernel.send(:find_kernel_packages, @remove_kernels).uniq).to eq @remove_packages
+    end
+  end
+
+  context "#confirm_removals(kernels_to_remove, installed_kernels)" do
+    before :each do
+      Cernel.stub!(:find_kernels).and_return(@kernels_hash)
+      ARGF.should_receive(:first).exactly(1).times.and_return('no')
+    end
+
+    context "when confirmation not met" do
+      it "raises system exit" do
+        expect(lambda do
+          Cernel.send(:confirm_removals, @remove_kernels)
+        end).to raise_error SystemExit
+      end
+
+      it "prints 'canceled' message" do
+        Kernel.stub!(:exit)
+
+        $stderr.should_receive(:puts).with("Canceled!")
+        Cernel.send(:confirm_removals, @remove_kernels)
+      end
+      
+      it "returns kernels_to_remove" do
+        Kernel.stub!(:exit)
+
+        expect(Cernel.send(:confirm_removals, @remove_kernels)).to eq @remove_kernels
+      end
+    end
+  end
+
+  context "#sort_properly(kernels)" do
+    it "pads dash-number" do
+      unsorted  = ["2.23.10-1", "3.2.0-8", "2.23.1-4", "3.2.0-11", "2.3.1-10", "2.23.1-34"]
+      sorted    = ["2.23.1-4", "2.23.1-34", "2.23.10-1", "2.3.1-10", "3.2.0-8", "3.2.0-11"]
+
+      expect(Cernel.send(:sort_properly, unsorted)).to eq sorted
+    end
+  end
+
+  context "#apt_options" do
+    it "returns a string of the options" do
+      $options[:assume_yes] = false
+      $options[:dry_run] =    false
+      expect(Cernel.send(:apt_options)).to eq ""
+
+      $options[:assume_yes] = true
+      $options[:dry_run] =    false
+      expect(Cernel.send(:apt_options)).to eq "-y"
+
+      $options[:assume_yes] = false
+      $options[:dry_run] =    true
+      expect(Cernel.send(:apt_options)).to eq "-s"
+
+      $options[:assume_yes] = true
+      $options[:dry_run] =    true
+      expect(Cernel.send(:apt_options)).to eq "-y -s"
+    end
+  end
+
+  context "#safe_ified_kernels_list" do
+    it "removes entries with letters" do
+      $options[:kernels_list] = "3.2.r-12 3.2.0-11 3.324.43-32 343 3.2.0-123"
+
+      expect(Cernel.send("safe_ified_kernels_list")).to eq ["3.2.0-11"]
+    end
+  end
+end
+

data/spec/lib/dekernel/message_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe 'Message' do
+  context "#installed_kernels(installed_kernels)" do
+    context "when installed_kernels = 0" do
+      it "returns 'no kernels found error' message" do
+        expect(Message.installed_kernels([])).
+          to match "ERROR: No kernels found in the /boot directory!"
+      end
+    end
+
+    context "when installed_kernels = 1" do
+      it "returns 'only one kernel found' message" do
+        expect(Message.installed_kernels(@installed_kernels.last(1))).
+          to match "Only one kernel found!"
+      end
+    end
+
+    context "when installed_kernels > 1" do
+      it "returns 'multiple kernels found' message" do
+        expect(Message.installed_kernels(@installed_kernels)).
+          to match "Found #{@installed_kernels.length} kernels installed:"
+      end
+    end
+
+    it "returns kernels as a string" do
+      expect(Message.installed_kernels(@installed_kernels)).
+        to match ["Found #{@installed_kernels.length} kernels installed:"].
+          concat(@installed_kernels.collect { |k| "  #{k}  " }).join("\n")
+    end
+  end
+
+  context "#other_kernels" do
+    context "when other_kernels.length is greater than 0" do
+      it "returns 'you have other kernels' message" do
+        Cernel.stub!(:find_kernels).and_return(@kernels_hash)
+        message = "### NOTE: You have kernels in your /boot directory " +
+                  "that have no corresponding packages installed." + "\n"
+                  "###       If you know you don't want those kernels, " +
+                  "you may want to remove them."
+
+        expect(Message.other_kernels).to match message
+      end
+
+      it "returns list and remove commands" do
+        Cernel.stub!(:find_kernels).
+          and_return(@kernels_hash)
+
+        [@other_kernels.first, "sudo ls -ahl ", "sudo rm -f "].each do |string|
+          expect(Message.other_kernels).to match string
+        end
+      end
+    end
+    
+    it "returns nothing if other_kernels.length == 0" do
+      Cernel.stub!(:find_kernels).and_return({ :all => @all_kernels, :installed => @all_kernels })
+      expect(Message.other_kernels).to be_empty
+    end
+  end
+
+  context "#purge_packages_success(kernels_to_remove)" do
+    it "returns successful purge message" do
+      string = [
+        "Successfully removed the kernel packages for: #{@all_kernels.drop(2).join(', ')}",
+        "",
+        "### NOTE: Usually apt-get will update your bootloader automatically,",
+        "###       but if you have any trouble you may need to update it manually."].join("\n")
+      expect(Message.purge_packages_success(@all_kernels.drop(2))).to match string
+    end
+  end
+
+  context "#purge_packages_failure(exit_code)" do
+    it "returns failed purge message" do
+      string = 'ERROR: apt-get purge failed with \"12345\"'
+      expect(Message.purge_packages_failure("12345")).to match string
+    end
+  end
+
+  context "#ask_to_confirm_kernels_to_remove(kernels_to_remove, installed_kernels)" do
+    it "returns 'multiple kernels message' when multiple kernels" do
+      output = Message.ask_to_confirm_kernels_to_remove(@installed_kernels.drop(1), @installed_kernels)
+      count = @installed_kernels.drop(1).length
+
+      expect(output).to match "The #{count} kernels marked with asterisks will be apt-get purged:"
+    end
+
+    it "returns 'singular kernel message' when only one kernel" do
+      output = Message.ask_to_confirm_kernels_to_remove(@installed_kernels.first(1),
+                                                      @installed_kernels)
+
+      ["The kernel marked with asterisks will be apt-get purged:",
+      "Are you sure you want to continue "].each do |string|
+        expect(output).to match string
+      end
+    end
+  end
+
+  it "responds to purge_packages_success and purge_packages_failure methods" do
+    ["success", "failure"].each do |boolean|
+      expect(Message).to respond_to("purge_packages_#{boolean}")
+    end
+  end
+
+  it "responds to list_command and remove_command methods" do
+    ["list", "remove"].each do |name|
+      expect(Message).to respond_to("#{name}_command")
+    end
+  end
+end
+

data/spec/lib/dekernel_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe 'deKernel' do
+  before :each do
+    $stdout.stub!(:puts)
+    Message.stub!(:other_kernels)
+    Kernel.stub!(:system).with("clear")
+    Cernel.stub!(:get_free_disk_space).and_return(12345)
+    Cernel.stub!(:ask_which_to_remove)
+    Cernel.stub!(:purge_packages_from_a_list_of_kernels)
+  end
+
+  it "prints 'generally recommended' message" do
+    $stdout.should_receive(:puts).
+      with("It's generally recommended to leave at least three of your latest kernels installed.\n\n")
+    DeKernel.run
+  end
+
+  it "calls Cernel.purge_packages_from_a_list_of_kernels(Cernel.ask_which_to_remove)" do
+    Cernel.should_receive(:ask_which_to_remove)
+    Cernel.should_receive(:purge_packages_from_a_list_of_kernels)
+    DeKernel.run
+  end
+
+  it "prints Message.other_kernels" do
+    $stdout.should_receive(:puts)
+    Message.should_receive(:other_kernels)
+    DeKernel.run
+  end
+
+  it "prints 'disk space freed' message" do
+    $stdout.should_receive(:puts).with("0 megabytes of disk space were freed.")
+    DeKernel.run
+  end
+
+  it "accepts a list of kernels to remove" do
+    $options[:kernels_list] = @remove_kernels.join(" ")
+    Cernel.should_not_receive(:ask_which_to_remove)
+    Cernel.should_receive(:purge_packages_from_a_list_of_kernels).with(@remove_kernels)
+
+    DeKernel.run
+  end
+
+  context "accepts 'all-except (n)' kernels" do
+    it "removes all except latest (n)" do
+      $options[:all_except] = 1
+      $options[:kernels_list] = @remove_kernels.join(" ")
+      Cernel.should_not_receive(:ask_which_to_remove)
+      Cernel.should_not_receive(:purge_packages_from_a_list_of_kernels).with($options[:kernels_list].split(" "))
+      Cernel.should_receive(:find_all_except_latest).with(1)
+      Cernel.should_receive(:purge_packages_from_a_list_of_kernels)
+
+      DeKernel.run
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rspec'
+
+require 'dekernel'
+require 'dekernel/cernel'
+require 'dekernel/message'
+
+RSpec.configure do |c|
+  c.before :all do
+    $options = { dry_run: false, assume_yes: false, kernels_list: nil,
+                 all_except: nil, no_confirm: false }
+
+    @all_kernels = ["2.3.56-1", "2.4.28-11", "3.2.0-11", "3.2.0-8"]
+    @installed_kernels = @all_kernels.drop(1)
+    @all_except_latest_one = @installed_kernels - ["3.2.0-11"]
+    @kernels_hash = { all: @all_kernels, installed: @installed_kernels }
+    @other_kernels = @all_kernels - @installed_kernels
+    @remove_kernels = @installed_kernels.drop(1)
+
+    @remove_packages = @remove_kernels.collect { |kernel|
+      ["linux-headers-#{kernel}",
+       "linux-headers-#{kernel}-generic",
+       "linux-image-#{kernel}-generic"]
+    }.flatten
+
+  end
+end
+

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: dekernel
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- david amick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: deKernel is a simple tool that finds installed kernels and automates
+  the removal of any you choose, freeing disk space. With optional flags, it can also
+  be automated for scripting.
+email: github@davidamick.com
+executables:
+- dekernel
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/dekernel
+- lib/dekernel.rb
+- lib/dekernel/cernel.rb
+- lib/dekernel/message.rb
+- spec/spec_helper.rb
+- spec/lib/dekernel_spec.rb
+- spec/lib/dekernel/cernel_spec.rb
+- spec/lib/dekernel/message_spec.rb
+homepage: https://github.com/snarlysodboxer/deKernel#dekernel
+licenses: []
+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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Remove old/unused kernel packages.
+test_files:
+- spec/spec_helper.rb
+- spec/lib/dekernel_spec.rb
+- spec/lib/dekernel/cernel_spec.rb
+- spec/lib/dekernel/message_spec.rb