fstab 0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 0"
+  gem "jeweler", "~> 1.8.4"
+  gem "rdoc"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 BVox World S.L.U.
+
+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,71 @@
+# fstab
+
+Linux fstab helper library
+
+# Usage
+
+Adding a new entry to fstab:
+
+    require 'fstab'
+
+    # Use default /etc/fstab
+    # With safe_mode only valid devices/filesystems will be added to fstab
+    # Trying to add non existant device or filesystem will raise an exception
+    #
+    # :backup => true will create a timestamped fstab backup before saving
+    # the changes
+    fstab = Fstab.new '/etc/fstab', :safe_mode => true, 
+                                    :backup => true, :backup_dir = '/etc/'
+    
+    # Asuming /dev/sda1 has a valid FS
+    # The library will use the FS UUID automatically by default even if the block device path
+    # was used as an argument. This is usually safer.
+    fstab.add_device '/dev/sda1', '/mnt', 'ext4', 'discard,errors=remount-ro', 0, 1
+
+    # You can use filesystem UUID also
+    fstab.add_device '15baeabd-b419-4a69-a306-bc550dc8355f', '/mnt', 'ext4', 'discard,errors=remount-ro', 0, 1
+
+    # List fstab entries
+    fstab.entries.each do |key, val|
+      puts val[:label] # FS label, may be nil
+      puts val[:uuid]  # FS UUID, nil if entry marked as invalid
+      puts val[:mount_point] 
+      puts val[:type]
+      puts val[:opts]
+      puts val[:dump]
+      puts val[:pass]
+      puts val[:special] # special FS, i.e. not a block device
+      puts val[:line_number] # line number for the FS in fstab
+      puts val[:invalid] # the parser marked the entry as invalid 
+    end
+
+Checking if a device is present in /etc/fstab:
+
+    fstab.has_device? '/dev/sda1' # => true
+    # Assuming /dev/sda1 UUID is 15baeabd-b419-4a69-a306-bc550dc8355f
+    fstab.has_device? '15baeabd-b419-4a69-a306-bc550dc8355f' # => true
+
+Some other helper methods:
+
+    # Return a hash of 'invalid' entries, i.e. device does not exist or the
+    # entry is malformed
+    fstab.invalid_entries
+    # Automatically remove invalid entries creating a backup file
+    fstab.remove_invalid_entries
+
+    # Get FS UUID
+    Fstab.get_uuid '/dev/sda1'
+
+    # Get FS label, assuming it has one
+    # return nil otherwise
+    Fstab.get_label '/dev/sda1'
+
+# Running the tests
+
+    rake spec
+
+# Copyright
+
+Copyright (c) 2012 BVox World S.L.U. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+require './lib/fstab.rb'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.version = Fstab::VERSION
+  gem.name = "fstab"
+  gem.homepage = "http://github.com/bvox/fstab"
+  gem.license = "MIT"
+  gem.summary = %Q{Linux fstab helper library}
+  gem.description = %Q{Linux fstab helper library}
+  gem.email = "rubiojr@bvox.net"
+  gem.authors = ["Sergio Rubio"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "fstab #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/fstab.rb

@@ -0,0 +1,288 @@
+class Fstab
+
+  VERSION = "0.1"
+
+  # if safe_mode true, non existing devices won't be added to fstab.
+  # Adding a non existing device to fstab will raise an exception.
+  # Trying to add a device without a filesystem will also rise an exception
+  #
+  def initialize(file = '/etc/fstab', opts = {})
+    @file = file
+    @contents = File.read file
+    @backup = opts[:backup].nil? ? true : opts[:backup]
+    @safe_mode = opts[:safe_mode].nil? ? true : opts[:safe_mode]
+    @backup_dir = opts[:backup_dir] || '/etc/'
+  end
+
+  def entries
+    parse
+  end
+
+  # :label => label or :uuid => uuid or :dev => dev_path
+  # :mount_point => mp
+  # :type => type 
+  # :opts => opts 
+  # :dump => dump
+  # :pass => pass
+  def add_entry(opts = {})
+    raise ArgumentError.new(":dev key is required (fs_spec).") unless opts[:dev]
+    dev = opts[:dev].strip.chomp
+    uuid = nil
+    label = nil
+    case dev
+    when /\/dev\// # device path
+      pdev = dev
+    when /^\/\/\w+(\.\w+)*((\/)|\w+|\.)*/ #smbfs/cifs
+    when /^(tmpfs|proc|usbfs|devpts|none|sysfs)/ #special FS
+    when /^\w+:\/?\w*(\/\w+)*/ # NFS
+    when /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i # UUID
+      uuid = dev
+    else # Asume FS label, rise exception if FS label does not exist 
+      if File.blockdev?("/dev/disk/by-label/#{dev}")
+        label = dev
+      else
+        raise Exception.new "Unsupported filesystem #{dev}" 
+      end
+    end
+
+    if opts[:mount_point].nil? or opts[:type].nil? or \
+       opts[:opts].nil? or opts[:dump].nil? or opts[:pass].nil?
+      raise ArgumentError.new("Missing :mount_point, :type, :opts, :dump or :pass options")
+    end
+
+    if @safe_mode
+      if label 
+        raise ArgumentError.new("Invalid device label #{label}") unless \
+              File.blockdev?("/dev/disk/by-label/#{opts[:label]}")
+        opts[:uuid] = Fstab.get_uuid_from_label(label) 
+      elsif uuid
+        raise ArgumentError.new("Invalid device UUID #{uuid}") unless \
+              File.blockdev?("/dev/disk/by-uuid/#{uuid}")
+        opts[:uuid] = uuid
+      elsif pdev
+        raise ArgumentError.new("Invalid device path #{pdev}") unless \
+              File.blockdev?("#{pdev}")
+        opts[:uuid] = Fstab.get_uuid(pdev)
+      else
+        # Asume special device
+        special = true
+      end
+      unless special
+        raise ArgumentError.new("Duplicated entry found (safe_mode=on)") if has_device?(dev)
+      end
+    end
+
+    backup_fstab
+    File.open @file, 'w' do |f|
+      f.puts @contents
+      f.puts format_entry(dev, opts)
+    end
+  end
+
+  def add_fs(dev, mpoint, type, opts, dump = 0, pass = 0)
+    o = {}
+    o[:dev] = dev
+    o[:mount_point] = mpoint
+    o[:type] = type 
+    o[:opts] = opts
+    o[:dump] = dump
+    o[:pass] = pass
+    add_entry o
+  end
+
+  def line_count
+    @lcount
+  end
+
+  def parse(reload = true)
+    @contents = File.read @file if reload
+    raise Exception.new("/sbin/blkid not found") unless File.exist?('/sbin/blkid')
+    fslist = {}
+    ucount = 0
+    @lcount = 0
+    @contents.each_line do |l|
+      next if l.strip.chomp.empty?
+      @lcount += 1
+      next if l =~ /\s*#/
+      fs, mp, type, opts, dump, pass = l.split
+      
+      # FSTAB(5) states that pass and dump are optional, defaults to 0
+      pass = "0" unless pass
+      dump = "0" unless dump
+      pdev = nil
+      label = nil
+      uuid = nil
+      special = false
+      if l =~ /^\s*LABEL=/
+        # by LABEL
+        label = fs.split("=").last.strip.chomp
+        pdev = "/dev/" + File.readlink("/dev/disk/by-label/#{label}").split("/").last rescue "unknown_#{ucount}"
+        uuid = Fstab.get_uuid pdev
+      elsif l =~ /^\s*UUID=/
+        # by UUID
+        uuid = fs.split("=").last.strip.chomp
+        pdev = "/dev/" + File.readlink("/dev/disk/by-uuid/#{uuid}").split("/").last rescue "unknown_#{ucount}"
+        label = Fstab.get_label pdev
+      elsif l =~ /^\s*\/dev/
+        # by dev path
+        pdev = fs
+        blkid = `/sbin/blkid #{pdev}`
+        label = blkid.match(/LABEL="(.*?)"/)[1] rescue nil
+        uuid = blkid.match(/UUID="(.*?)"/)[1] rescue nil
+      else
+        # FIXME: somewhat risky to assume that everything else
+        # can be considered a special device, but validating this
+        # is really tricky.
+        special = true
+        pdev = fs
+      end
+      # Fstab entries not matching real devices have pdev unknown
+      invalid = (l.split.count != 6) # invalid entry if < 6 columns
+      if (uuid.nil? and label.nil? and !special) or 
+         pdev =~ /^unknown_/ or \
+         (!File.exist?(pdev) and !special) 
+        invalid = true
+        ucount += 1
+      end
+
+      invalid = true unless (dump =~ /0|1|2/ and pass =~ /0|1|2/)
+
+      fslist[pdev] = { 
+        :label => label, 
+        :uuid => uuid, 
+        :mount_point => mp,
+        :type => type, 
+        :opts => opts, 
+        :dump => dump,
+        :pass => pass,
+        :special => special,
+        :line_number => @lcount,
+        :invalid => invalid,
+      } 
+    end 
+    fslist
+  end
+
+  def valid_entries
+    Hash[parse.find_all { |k,v| !v[:invalid] }]
+  end
+
+  def auto_header
+    @header ||= "#\n" +
+                "# This file was autogenerated at #{Time.now.to_s}\n" +
+                "#\n"
+  end
+  
+  # 
+  # May rise exception 
+  #
+  def remove_invalid_entries
+    return false if invalid_entries.empty?
+    backup_fstab
+    File.open @file, 'w' do |f|
+      f.puts auto_header
+      valid_entries.each do |k,v|
+        f.puts format_entry(k, v)
+      end
+    end
+    true
+  end
+
+  def invalid_entries 
+    Hash[parse.find_all { |k,v| v[:invalid] }]
+  end
+
+  #
+  # Accepts UUID/LABEL/dev
+  #
+  def find_device(dev)
+    # get canonical device_name
+    begin
+      dev = Fstab.get_blockdev(dev)
+      parse.each do |k, v|
+        return { k => v } if k == dev
+      end
+    rescue
+    end
+    nil
+  end
+  
+  def has_device?(dev)
+    !find_device(dev).nil?
+  end
+
+  # returns 
+  # {
+  #   :uuid   => UUID,
+  #   :label  => LABEL,
+  #   :fstype => FSTYPE,
+  #   :dev    => DEVICE
+  # }
+  #
+  # All the attributes except dev may be nil at any given time since
+  # device may not have a valid filesystem or label.
+  def self.get_blkdev_fs_attrs(dev)
+    raise ArgumentError.new("Invalid device path") unless File.blockdev?(dev)
+    blkid = `/sbin/blkid #{dev}`
+    attrs = {}
+    attrs[:uuid] = blkid.match(/UUID="(.*?)"/)[1] rescue nil
+    attrs[:label] = blkid.match(/LABEL="(.*?)"/)[1] rescue nil
+    attrs[:fstype] = blkid.match(/TYPE="(.*?)"/)[1] rescue nil
+    attrs[:dev] = blkid.match(/\/dev\/(.*):/)[1] rescue nil
+    attrs
+  end
+
+  # 
+  # Get block device from UUID/Label
+  def self.get_blockdev(id)
+    if File.blockdev?(id) and !File.symlink?(id)
+      return id
+    end
+    path = nil
+    # Try to get blockdev from UUID first, then label
+    begin
+      path = File.readlink("/dev/disk/by-uuid/#{id}")
+    rescue
+      path = File.readlink("/dev/disk/by-label/#{id}") 
+    end
+    "/dev/#{path.split('/').last}"
+  end
+
+  def self.get_uuid(dev)
+    #`/sbin/blkid #{dev}`.match(/UUID="(.*?)"/)[1] rescue nil
+    Fstab.get_blkdev_fs_attrs(dev)[:uuid]
+  end
+  
+  def self.get_uuid_from_label(label)
+    Fstab.get_blkdev_fs_attrs("/dev/disk/by-label/#{label}")[:uuid]
+  end
+
+  def self.get_label(dev)
+    Fstab.get_blkdev_fs_attrs(dev)[:label]
+  end
+
+  private
+  def format_entry(dev, values)
+    if values[:special]
+      "#{dev} #{values[:mount_point]} #{values[:type]} " +
+      "#{values[:opts]} #{values[:dump]} #{values[:pass]}"
+    else
+      if values[:uuid]
+        "UUID=#{values[:uuid]} #{values[:mount_point]} #{values[:type]} " +
+        "#{values[:opts]} #{values[:dump]} #{values[:pass]}"
+      else
+        "#{dev} #{values[:mount_point]} #{values[:type]} " +
+        "#{values[:opts]} #{values[:dump]} #{values[:pass]}"
+      end
+    end
+  end
+
+  def backup_fstab
+    return unless @backup
+    File.open("#{@backup_dir}/fstab.#{Time.now.to_f}.bak", 'w') do |f|
+      f.puts @contents
+    end
+  end
+
+end
+

data/spec/fstab_helper_spec.rb

@@ -0,0 +1,309 @@
+require 'spec_helper'
+
+describe Fstab do
+
+  before :each do
+    @fake_fstab =  "/tmp/fstab.#{Time.now.to_f}.fake"
+    File.open @fake_fstab, 'w' do |f|
+      f.puts ""
+    end
+
+    @real_fstab = "/tmp/fstab.#{Time.now.to_f}.real"
+    File.open @real_fstab, 'w' do |f|
+      f.puts File.read('/etc/fstab')
+    end
+  end
+
+  after :each do
+    File.delete @fake_fstab
+    File.delete @real_fstab
+    Dir["/tmp/fstab*.bak"].each do |f|
+      File.delete f
+    end
+  end
+
+  describe "#new" do
+    it "accepts two optional arguments" do
+      h = Fstab.new '/etc/fstab', {}
+    end
+    
+    it "raises exception unless opts is not Hash" do
+      lambda { Fstab.new(@real_fstab, false) }.should raise_error NoMethodError
+    end
+
+    it "accepts no arguments" do
+      h = Fstab.new
+    end
+
+    it "raises exception if file does not exist" do
+      lambda { Fstab.new('/tmp/lkjsdfouwoiue') }.should raise_exception(Errno::ENOENT)
+    end
+    
+    it "reads custom #{@fake_fstab}" do
+      h = Fstab.new @fake_fstab
+      h.instance_variable_get(:@contents).strip.chomp.should be_empty 
+    end
+
+    it "has backups enabled by default" do
+      h = Fstab.new @fake_fstab
+      h.instance_variable_get(:@backup).should be_true
+    end
+
+  end
+
+  describe "#parse" do
+    it "should count lines" do
+      count = File.read('/etc/fstab').lines.count
+      f = Fstab.new(@real_fstab); f.parse
+      f.line_count.should be count
+    end
+
+    it "should return empty Hash if empty" do
+      Fstab.new(@fake_fstab).parse.should be_empty
+    end
+    it "should have 1 special FS" do
+      File.open @fake_fstab, 'w+' do |f|
+        f.puts 'proc            /proc           proc    nodev,noexec,nosuid 0       0'
+        f.flush
+        fstab = Fstab.new @fake_fstab
+        devs = fstab.parse
+        devs.count.should == 1
+        # d[:special] == true
+        devs.first.last[:special].should == true
+      end
+    end
+
+    it "should detect special filesystems as valid" do
+      File.open @fake_fstab, 'w+' do |f|
+        f.puts 'proc            /proc           proc    nodev,noexec,nosuid 0       0'
+        f.flush
+        fstab = Fstab.new @fake_fstab
+        devs = fstab.parse
+        devs.count.should == 1
+        devs.first.last[:invalid].should == false
+      end
+    end
+    
+    it "should detect invalid dump/pass columns" do
+      File.open @fake_fstab, 'w+' do |f|
+        f.puts 'proc            /proc           proc    nodev,noexec,nosuid a b'
+        f.flush
+        fstab = Fstab.new @fake_fstab
+        devs = fstab.parse
+        devs.count.should == 1
+        devs.first.last[:invalid].should == true
+      end
+    end
+
+    it "should detect invalid filesystems" do
+      File.open @fake_fstab, 'w+' do |f|
+        f.puts '/dev/foobar /tmp/bar           xfs    defaults 0       0'
+        f.flush
+        fstab = Fstab.new @fake_fstab
+        devs = fstab.parse
+        devs.count.should == 1
+        devs.first.last[:invalid].should == true
+        f.puts 'weird_entry foo bar'
+        f.flush
+        devs = fstab.parse
+        devs.count.should == 2
+        devs.each do |k,v|
+          v[:invalid].should == true
+        end
+      end
+    end
+  end
+
+  describe "#add_fs" do
+    it "should raise an exception adding a non existing device" do
+      f = Fstab.new(@real_fstab)
+      lambda {f.add_fs '/dev/fff', '/foo/bar', 'xfs', 'defaults'}.should \
+        raise_error /Invalid device path/
+    end
+    it "should raise an exception adding a non existing dev label" do
+      f = Fstab.new(@real_fstab)
+      lambda {f.add_fs 'my-foo-fs', '/foo/bar', 'xfs', 'defaults'}.should \
+        raise_error /Unsupported filesystem/
+    end
+    it "should raise an exception adding a non existing dev uuid" do
+      f = Fstab.new(@real_fstab)
+      lambda {f.add_fs 'ca803c3f-32e6-423e-994a-52f648a0321d', '/foo/bar', 'xfs', 'defaults'}.should \
+        raise_error /Invalid device UUID/
+    end
+    it "should raise an exception adding a non existing dev label" do
+      f = Fstab.new(@real_fstab)
+      lambda {f.add_fs 'my-foo-fs', '/foo/bar', 'xfs', 'defaults'}.should \
+        raise_error /Unsupported filesystem/
+    end
+
+    it "should add invalid device when safe_mode=false" do
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup_dir => '/tmp')
+      f.add_fs '/dev/foo_dev', '/foo/bar', 'xfs', 'defaults'
+      f.invalid_entries.count.should == 1
+    end
+
+    it "should create a backup when backup=true (default)" do
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup_dir => '/tmp')
+      f.add_fs '/dev/foo_dev', '/foo/bar', 'xfs', 'defaults'
+      Dir["/tmp/fstab*.bak"].count.should == 1
+    end
+    
+    it "should NOT create a backup when backup=false" do
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      f.add_fs '/dev/foo_dev', '/foo/bar', 'xfs', 'defaults'
+      Dir["/tmp/fstab*.bak"].count.should == 0
+    end
+
+    it "should add a valid special FS entry" do
+      f = Fstab.new(@fake_fstab, :backup => false, :backup_dir => '/tmp')
+      prev_count = f.parse.count
+      f.add_fs 'tmpfs', '/foo/bar', 'tmpfs', 'size=1024', '0', '0'
+      f.parse.count.should == prev_count + 1
+      File.read(@fake_fstab).should match /^tmpfs/m
+    end
+    
+    it "should add a FS UUID" do
+      f = Fstab.new(@fake_fstab, :safe_mode => true, :backup => false, :backup_dir => '/tmp')
+      pdev, uuid, label, type = get_first_blkid
+      f.add_fs uuid, '/foo/bar', type, 'defaults', '0', '0'
+      File.read(@fake_fstab).should match /^UUID=#{uuid}/m
+    end
+    
+    it "should add a FS UUID when using a blockdev" do
+      f = Fstab.new(@fake_fstab, :safe_mode => true, :backup => false, :backup_dir => '/tmp')
+      pdev, uuid, label, type = get_first_blkid
+      f.add_fs pdev, '/foo/bar', type, 'defaults', '0', '0'
+      File.read(@fake_fstab).should match /^UUID=#{uuid}/m
+    end
+
+    it "should raise error when adding duplicated entry and safe_mode=true" do
+      f = Fstab.new(@fake_fstab, :backup => false, :backup_dir => '/tmp')
+      pdev, uuid, label, type = get_first_blkid
+      f.add_fs uuid, '/foo/bar', type, 'defaults', '0', '0'
+      lambda {f.add_fs uuid, '/foo/bar', type, 'defaults', '0', '0'}.should raise_error /Duplicated entry found/
+      lambda {f.add_fs pdev, '/foo/bar', type, 'defaults', '0', '0'}.should raise_error /Duplicated entry found/
+    end
+  end
+
+  describe "#add_entry" do
+    it "should raise an exception when missing mount_point/type/opts,dump,pass" do
+      f = Fstab.new(@real_fstab)
+      opts = {
+        :dev => '/dev/sda',
+        :mount_point => '/foo/bar',
+        :type => 'xfs',
+        :opts => 'defaults',
+        :dump => 0,
+        :pass => 0
+      }
+      [:mount_point, :type, :opts, :dump, :pass].each do |s|
+        dup_opts = opts.dup; dup_opts.delete s
+        lambda {f.add_entry dup_opts}.should \
+          raise_error /Missing :mount_point, :type, :opts/
+      end
+    end
+
+    it "should raise and exception when dev/uuid/label nil" do
+      f = Fstab.new(@real_fstab)
+      opts = {
+        :mount_point => '/foo/bar',
+        :type => 'xfs',
+        :opts => 'defaults',
+        :dump => 0,
+        :pass => 0
+      }
+      lambda {f.add_entry opts}.should \
+        raise_error /:dev key is required/
+    end
+  end
+  
+  describe "#invalid_entries" do
+    it "should return one entry" do
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      f.add_fs '/dev/foo_dev', '/foo/bar', 'xfs', 'defaults'
+      f.invalid_entries.count.should == 1
+    end
+  end
+  
+  describe "#valid_entries" do
+    it "should only return valid entries" do
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      f.add_fs '/dev/foo_dev', '/foo/bar', 'xfs', 'defaults'
+      lcount = File.read(@real_fstab).lines.find_all do |l| 
+        (l.strip.chomp !~ /^#/) and !l.strip.chomp.empty?
+      end.count
+      f.valid_entries.count.should == lcount - 1
+    end
+
+    it "should match the number of devices" do
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      f.valid_entries.count.should == f.parse.count
+    end
+  end
+
+  describe "#remove_invalid_entries" do
+    it "should remove 1 entry" do
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      prev_count = f.parse.count
+      f.add_fs '/dev/foo_dev', '/foo/bar', 'xfs', 'defaults'
+      f.remove_invalid_entries.should == true
+    end
+  end
+
+  describe "#find_device" do
+    it "should return nil if device not found" do
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      f.find_device('/alksjdflkjsd').should be_nil
+    end
+
+    it "should return a valid device if device is defined" do
+      pdev, uuid, label, type = get_first_blkid
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      f.add_fs pdev, '/foo/bar', type, 'defaults'
+      f.find_device(pdev).should be_a Hash
+      k, dev = f.find_device(pdev).first
+      dev.should_not be_nil
+      k.should match pdev
+      dev[:mount_point].should match '/foo/bar'
+    end
+  end
+
+  describe "#has_device?" do
+    it "should return true if device is defined" do
+      pdev, uuid, label, type = get_first_blkid
+      f = Fstab.new(@fake_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      f.add_fs pdev, '/foo/bar', type, 'defaults'
+      f.has_device?(pdev).should == true
+      f.has_device?(uuid).should == true
+    end
+    it "should return true if device is defined" do
+      pdev, uuid, label, type = get_first_blkid
+      f = Fstab.new(@real_fstab, :safe_mode => false, :backup => false, :backup_dir => '/tmp')
+      f.add_fs pdev, '/foo/bar', type, 'defaults'
+      f.has_device?(pdev).should == true
+    end
+  end
+  
+  describe "get_label" do
+    it "should raise exception for an invalid device" do
+      lambda {Fstab.get_label('/akjsdfljaslkdj')}.should raise_error ArgumentError
+    end
+
+    it "should return a valid LABEL for device with a labeled FS" do
+      pdev, uuid, label, type = get_first_blkid
+      Fstab.get_label(pdev).should be_nil
+      Fstab.get_uuid(pdev).should match uuid
+      if label.nil?
+        Fstab.get_label(pdev).should be_nil
+      end
+    end
+  end
+
+  describe "get_uuid" do
+    it "should return a valid UUID for device with a FS" do
+      pdev, uuid, label, type = get_first_blkid
+      Fstab.get_uuid(pdev).should match uuid
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$: << File.join(File.dirname(__FILE__), '../lib')
+require 'fstab'
+
+def get_first_blkid
+  blkid = `/sbin/blkid`.lines.first
+  uuid = blkid.match(/UUID="(.*?)"\s+/)[1] 
+  label = blkid.match(/LABEL="(.*?)"\s+/)[1] rescue nil
+  type = blkid.match(/TYPE="(.*?)"\s+/)[1]
+  pdev = blkid.match(/(\/dev\/.*?):/)[1] 
+  return pdev, uuid, label, type
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: fstab
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Sergio Rubio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-08 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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Linux fstab helper library
+email: rubiojr@bvox.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/fstab.rb
+- spec/fstab_helper_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/bvox/fstab
+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'
+      segments:
+      - 0
+      hash: 866801040596206319
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Linux fstab helper library
+test_files: []