usefuldb 0.0.7 → 0.0.8

data/CHANGELOG

@@ -1,5 +1,10 @@
 usefuldb gem CHANGELOG
 
+## Version 0.0.8
+- Fixed issue introduced in 0.0.7 with deleting elements 
+- Added logging to many parts of the UsefulDB system to aid debugging, and provide support for verbose mode 
+- Updated main_test.rb to match the updated interface, and consolidated test methods
+
 ## Version 0.0.7
 - Updated layout of the yaml database file to include description field for each entry
 - Updated layout of the yaml database file to include a version field

data/README

@@ -1,4 +1,4 @@
-## Readme - v0.0.6
+## Readme - v0.0.8
 
 ### Install
 To run the unit tests use the following rake target

data/bin/usefuldb

@@ -1,7 +1,9 @@
 #!/usr/bin/env ruby
 
+# Require statements
 require 'usefuldb'
 require 'optparse'
+require 'logger'
 
 #####################################################
 def addColour(text, colour_code)
@@ -14,11 +16,20 @@ def yellow(text); addColour(text, 33); end
 def blue(text); addColour(text, 34); end
 #####################################################
 
+# Variables
+
+# Create the Logger instance
+log = Logger.new(STDOUT)
+#log.level = Logger::DEBUG
+#log.level = Logger::INFO
+log.level = Logger::WARN
+
+
 options = {}
 optparse = nil
 
 # Setup the system for use
-UsefulDB.setup
+UsefulDB.setup(log)
 
 begin
   optparse = OptionParser.new do |opts|
@@ -31,22 +42,27 @@ UsefulDB - a simple command and URL database (#{UsefulDB::Version})
 WELCOME
   
     opts.on('-a', '--add', "Add an entry to the database") do |arg|
+      log.debug "add parameter passed"
       options[:a] = arg
     end
     
     opts.on('-d', '--delete', "Delete an entry from the database") do |arg|
+      log.debug "delete parameter passed"
       options[:d] = arg
     end
     
     opts.on('-l', '--list', "List all entries in the database") do |arg|
+      log.debug "list parameter passed"
       options[:l] = arg
     end
     
     opts.on('-v', '--verbose', "Runs the system in verbose mode") do |arg|
+      log.debug "verbose parameter passed"
       options[:v] = arg
     end
     
     opts.on('-h', '--help', "Print out this message") do |arg|
+      log.debug "help parameter passed"
       puts opts
       exit
     end
@@ -54,41 +70,52 @@ WELCOME
   end.parse!
 rescue OptionParser::InvalidOption => e
   puts e.message + "\n\nUseage: usefuldb -h or --help for help using the system"
+  log.fatal e.message
   exit()
 end
 
 #############################################################################
 
 # Checking for flag parameters
+log.debug "Checking for parameters"
 if options.empty?
-  # No parameters of any kind were passed
+  log.debug "No flag parameters were passed"
+  log.debug "Checking if ARGV is empty"
   if ARGV.empty?
+    log.debug "No parameters of any kind were passed, exiting"
     puts "Useage: usefuldb -h or --help for help using the system"
     exit()
-  
-  # At least one non flag parameter was passed
   else
-    puts green("Launching the search system:")
-    UsefulDB::GUI.search(ARGV)
+    log.debug "At least one non flag parameter was passed, launching the search system"
+    log.debug ARGV
+    puts "Launching the search system:"
+    UsefulDB::GUI.search(ARGV, log)
   end
 
-# Some flags parameters were passed
 else
-  #puts options
+  log.debug "Some flags parameters were passed"
+  log.debug options
   
-  if options[:a] # The -a or --add flag check
-    puts green("Launching the add system:")
-    UsefulDB::GUI.add(options)
+  if options[:v]
+    log.level = Logger::INFO
+  end
+  
+  if options[:a]
+    log.debug "The -a or --add flag is true, launching add system"
+    puts "Launching the add system:"
+    UsefulDB::GUI.add(log)
   
   elsif options[:l]
+    log.debug "The -l or --list flag is true, launching the list system"
     puts green("Launching the list system:")
-    UsefulDB::GUI.list
+    UsefulDB::GUI.list(log)
     
-  elsif options[:d] # The -d or --delete flag check
+  elsif options[:d]
+    log.debug "The -d or --delete flag is true, launching the delete system"
     puts "Run the delete system:"
-    UsefulDB::GUI.remove(options)
-    
+    UsefulDB::GUI.remove(log)
   end
+  
 end
 
 

data/lib/usefuldb.rb

@@ -4,36 +4,37 @@ require 'usefuldb/exceptions'
 require 'usefuldb/gui'
 require 'usefuldb/version'
 require 'fileutils'
+require 'logger'
 
 module UsefulDB
   class << self
         
-    def add(hash, opts)
-      UsefulDB::UsefulUtils.add(hash, opts)
+    def add(hash, log)
+      UsefulDB::UsefulUtils.add(hash, log)
     end
   
-    def count()
-      UsefulDB::UsefulUtils.count
+    def count(log)
+      UsefulDB::UsefulUtils.count(log)
     end
     
-    def remove(key, opts)
-      UsefulDB::UsefulUtils.remove(key, opts)
+    def remove(key, log)
+      UsefulDB::UsefulUtils.remove(key, log)
     end
     
-    def dbSave
-      UsefulDB::UsefulUtils.dbSave
+    def dbSave(log)
+      UsefulDB::UsefulUtils.dbSave(log)
     end
     
-    def dbLoad
-      UsefulDB::UsefulUtils.dbLoad
+    def dbLoad(log)
+      UsefulDB::UsefulUtils.dbLoad(log)
     end
     
-    def search(args)
-      return UsefulDB::UsefulUtils.search(args)
+    def search(args, log)
+      return UsefulDB::UsefulUtils.search(args, log)
     end
     
-    def setup
-      UsefulDB::UsefulUtils.setup
+    def setup(log)
+      UsefulDB::UsefulUtils.setup(log)
     end
 
   end

data/lib/usefuldb/gui.rb

@@ -5,16 +5,28 @@ module UsefulDB
   class GUI
     class << self
       attr_accessor 
-       
-      def search(args)
-        UsefulDB.dbLoad
-        args.each {|i| puts "\n" + UsefulDB::UsefulUtils.search(i)} 
+      
+      
+      # Search the database
+      def search(args, log)
+        log.debug "Loading the database"
+        UsefulDB.dbLoad(log)
+        
+        log.debug "Launching UsefulDB::UsefulUtils.search"
+        args.each {|i| puts "\n" + UsefulDB::UsefulUtils.search(i, log)} 
       end
       
-      def list
-        UsefulDB.dbLoad
+      
+      # List entries in the database
+      def list(log)
+        log.debug "Loading the database"
+        UsefulDB.dbLoad(log)
+        
+        log.debug "Launching UsefulDB::UsefulUtils.list"
         index = 0
-        UsefulDB::UsefulUtils.list.each do |i|
+        listing = UsefulDB::UsefulUtils.list(log)
+        
+        listing.each do |i|
           puts "Element: " + index.to_s
           index += 1
           msg = ''
@@ -23,62 +35,67 @@ module UsefulDB
           puts "- Value: " + i["value"]
           puts "- Description: " + i["description"] + "\n\n##\n" 
         end
+        
+        log.info "Number of entries in the database is: " + UsefulDB::UsefulUtils.count(log).to_s
       end
       
       
-      
-      def remove(opts)
-        if opts[:v] then puts "in verbose mode\n"; end
-        list()
+      # Remove an entry from the database
+      def remove(log)
+        log.info "Printing out the list of database entries\n"
+        list(log)
         
         puts "Enter the number of the element from the list above which you want to delete"
         value = STDIN.gets
+        log.debug value
                 
         begin
-          UsefulDB.remove(value.to_i, {})
-          UsefulDB.dbSave
+          UsefulDB.remove(value.to_i, log)
+          log.info "Entry removed"
+          UsefulDB.dbSave(log)
+          log.info "Saving database"
         rescue KeyOutOfBounds => e
           puts e.message + "\nexiting."
+          log.fatal e.message
           exit()
         end
         
       end
       
-       
-      def add(opts)
-        UsefulDB.dbLoad
+      
+      # Add element to the database
+      def add(log)
+        UsefulDB.dbLoad(log)
         
-        if opts[:v]
-          puts "in verbose mode\n"
-          puts "Please enter the comma separated search tags like the following:"
-          puts "eg:\nterm1, term2, term3\n\n"
-        else
-          puts "Please enter the comma separated search tags like the following:"
-        end
+        puts "Please enter the comma separated search tags like the following:"
+        log.info "eg:\nterm1, term2, term3\n\n"
         
         begin
           tags = ((STDIN.gets).strip).split(', ')
-                    
+          log.debug tags.inspect          
+          
           puts "Please enter the value you wish to store for this database entry:"
           value = (STDIN.gets).strip
+          log.debug value
           
           puts "Please enter a description for this entry: "
           description = (STDIN.gets).strip
+          log.debug description
           
           entry = {"tag" => tags, "value" => value, "description" => description}
           
-          if opts[:v]
-            puts "Storing the following in the database:\n" 
-            puts "Search tags: " + UsefulDB::UsefulUtils.array_to_s(tags)
-            puts "Entry Value: " + value
-            puts "Description: " + description
-          end
+          log.info "Storing the following in the database:" 
+          log.info "Search tags: " + UsefulDB::UsefulUtils.array_to_s(tags)
+          log.info "Entry Value: " + value
+          log.info "Description: " + description
               
-          UsefulDB.add(entry, {})
-          UsefulDB.dbSave
+          UsefulDB.add(entry, log)
+          UsefulDB.dbSave(log)
+          log.info "Saving database"
           
         rescue Exception => e
           puts e.message
+          log.fatal e.message
           exit
         end
         

data/lib/usefuldb/settings.rb

@@ -5,28 +5,32 @@ module UsefulDB
   class Settings
     class << self
   
-      attr_accessor :data
+      attr_accessor :data;
       
       # Loads the database from disk
-      def load(path)
+      def load(path, log)
         begin
           @data = YAML.load(File.open(path))
           
           if @data.class == Array
-            puts "Assuming currently installed DB version < 0.0.7 running autoConvert"
-            autoConvert()
-            save(@data, path)
+            log.warn "Assuming currently installed DB version < 0.0.7 running autoConvert"
+            
+            autoConvert(log)
+            log.warn "Database conversion successful"
+            save(@data, path, log)
+            log.debug "Saving the database"
           elsif @data["version"] != UsefulDB::Version.to_s
-            puts "The database version is lower than the latest version running autoUpgrade"
-            autoUpgrade()
-            save(@data, path)
+            log.warn "The database version is lower than the latest version running autoUpgrade"
+            
+            autoUpgrade(log)
+            log.warn "Database upgrade successful"
+            save(@data, path, log)
+            log.debug "Saving the database"
           else
-            #puts "Database version is current"
+            log.debug "Database version is current"
           end
           
-          
-          # Debug
-          #puts @data.inspect
+          log.debug @data.inspect
           
         rescue ArgumentError => e
           exit("Could not parse YAML: #{e.message}")
@@ -35,7 +39,7 @@ module UsefulDB
       
       
       # Saves the database to disk
-      def save(newData, path)
+      def save(newData, path, log)
         @data = newData
         f = File.open(path, "w")
         f.write(@data.to_yaml)
@@ -44,8 +48,8 @@ module UsefulDB
       
       
       # Converts from db versions < 0.0.6 to the structure introduced in version 0.0.7
-      def autoConvert()
-        puts "autoConvert Method executing"
+      def autoConvert(log)
+        log.warn "autoConvert Method executing"
         convertedDB = {"version" => UsefulDB::Version.to_s, "db" => @data}
         
         convertedDB["db"].each do |element|
@@ -57,8 +61,8 @@ module UsefulDB
       
       
       # Convert the db from versions lower than the latest version of usefuldb to the latest version
-      def autoUpgrade()
-        puts "autoUpgrade Method executing"
+      def autoUpgrade(log)
+        log.warn "autoUpgrade Method executing"
         @data["version"] = UsefulDB::Version.to_s
       end
       

data/lib/usefuldb/utilities.rb

@@ -1,4 +1,5 @@
 require 'usefuldb/exceptions'
+require 'logger'
 
 module UsefulDB
 
@@ -20,28 +21,28 @@ module UsefulDB
       
       
       # Save the database to disk
-      def dbSave()
+      def dbSave(log)
         if @dbpath.nil?
-          #@dbpath = File.expand_path(File.dirname(__FILE__) + '/../../resources/db.yaml')
+          log.debug @dbpath = File.expand_path(File.dirname(__FILE__) + '/../../resources/db.yaml')
           @dbpath = ENV['HOME'] + "/.usefuldb/db.yaml"
-          Settings.save(@data, @dbpath)
+          UsefulDB::Settings.save(@data, @dbpath, log)
         else
-          Settings.save(@data, @dbpath)
+          UsefulDB::Settings.save(@data, @dbpath, log)
         end
       end
       
       
       # Load the database from disk
-      def dbLoad()
-        #@dbpath = File.expand_path(File.dirname(__FILE__) + '/../../resources/db.yaml')
+      def dbLoad(log)
+        log.debug @dbpath = File.expand_path(File.dirname(__FILE__) + '/../../resources/db.yaml')
         @dbpath = ENV['HOME'] + "/.usefuldb/db.yaml"
-        Settings.load(dbpath)
-        @data = Settings.data
+        UsefulDB::Settings.load(@dbpath, log)
+        @data = UsefulDB::Settings.data
       end
       
       
       # Return the number of elements in the database.
-      def count()
+      def count(log)
         if @data["db"].count == 0
           raise EmptyDB, "The DB is currently empty."
         else
@@ -51,39 +52,42 @@ module UsefulDB
       
       
       # Add an element to the database
-      def add(hash, opts)
+      def add(hash, log)
         if @data["db"].include?(hash) then raise EntryInDB, "Entry already in the DB"; else @data["db"] << hash; end    
       end
   
       
       # Remove an element from the database
-      def remove(key, opts)
+      def remove(key, log)
         if @data["db"].count == 0
           raise EmptyDB, "You cannot call the remove function on an empty Database!"
         elsif @data["db"].count <= key || key < 0
           raise KeyOutOfBounds, "Key is out of bounds and therefore does not exist in the DB"
         else
-          @data.delete_at(key) 
+          @data["db"].delete_at(key) 
         end
       end
       
       
       # Setup the system for the first time
-      def setup()
+      def setup(log)
+        log.debug "Checking to see if the database is already installed"
         resourceDir = ENV['HOME'] + "/.usefuldb/"
+        log.debug resourceDir
         if File.directory?(resourceDir) 
-          # The folder already exists, do nothing
+          log.debug "The folder already exists, do nothing"
         else
-          # We need to create this folder and install the DB there.
+          log.debug "Creating ~/.usefuldb/ and installing the DB there."
           FileUtils.mkdir(resourceDir)
           dbpath = File.expand_path(File.dirname(__FILE__) + '/../../resources/db.yaml')
           FileUtils.cp(dbpath, resourceDir)
+          log.debug "Database copied to ~/.usefuldb/db.yaml"
         end
       end
       
       
       # Search for a tag in the DB
-      def search(tag)
+      def search(tag, log)
         msg = "Searching the database for tag: " + tag + "\n"
         
         @data["db"].each do |db|
@@ -98,7 +102,7 @@ module UsefulDB
       
       
       # List out all elements in the DB
-      def list
+      def list(log)
         return @data["db"]
       end
 

data/lib/usefuldb/version.rb

@@ -7,7 +7,7 @@ module UsefulDB
       
       MAJOR = 0 unless defined? MAJOR
       MINOR = 0 unless defined? MINOR
-      PATCH = 7 unless defined? PATCH
+      PATCH = 8 unless defined? PATCH
 
       def to_s
         [MAJOR, MINOR, PATCH].compact.join('.')

data/test/main_test.rb

@@ -2,9 +2,12 @@ require 'test/unit'
 require 'rack/test'
 require 'fileutils'
 require 'usefuldb'
+require 'logger'
 
 ENV['RACK_ENV'] = 'test'
 
+log = nil
+
 #####################################################
 def addColour(text, colour_code)
   "\e[#{colour_code}m#{text}\e[0m"
@@ -17,149 +20,83 @@ def blue(text); addColour(text, 34); end
 #####################################################
 
 
+
+
 class UsefulDBTest < Test::Unit::TestCase
 
   include Rack::Test::Methods
   
+  attr_accessor :log
+  
   def setup
-    UsefulDB.dbLoad
+  
+    if @log == nil
+      @log = log = Logger.new(STDOUT)
+      @log.level = Logger::INFO
+    end
+    
+    UsefulDB::dbLoad(@log)
   end
 
-  #def teardown
-  #  UsefulUtils.dbSave
-  #end
+  def teardown
+    # Do nothing
+  end
 
 
   # Test to check adding of entries to the database
   def test_add
-    puts yellow("## Executing test_add")
+    @log.info "Executing test: test_add"
+  
+    startingCount = UsefulDB.count(@log)
+    @log.info "The number of starting database entries: " + startingCount.to_s
   
     begin
-      puts "Check the starting count in the DB is 2 entries: " +
-      blue(assert_equal(2, UsefulDB.count()).to_s)
-    
-      entry = {"tag" => ["install", "rubygems", "website", "usefuldb"], "value" => "http://rubygems.org/usefuldb"}
-      puts "Create a new entry: " + entry.inspect
-    
-      puts "Test to check adding duplicate element to the DB fails"
-      UsefulDB.add(entry, {})
+      @log.info "Test to check adding an element to the database succeeds"
+      entry1 = {"tag" => ["testing", "the", "database", "dbtest"], "value" => "dbtest", "description" => "dbtest"}
+      @log.info "Create a new entry:" + entry1.inspect
+      UsefulDB.add(entry1, @log)
+      @log.info "Adding element to the database"
+      
+      @log.info "Check the total number of entries in the DB was increased by one " +
+      assert_equal(startingCount + 1, UsefulDB.count(@log)).to_s      
+      
+      @log.info "Test to check adding duplicate element to the DB fails"
+      entry2 = {"tag" => ["install", "rubygems", "website", "usefuldb"], "value" => "http://rubygems.org/usefuldb", "description" => "Website URL for the usefuldb gem"}
+      @log.info "Create a new entry: " + entry2.inspect
+      UsefulDB.add(entry2, @log)
       
     rescue UsefulDB::EmptyDB => e
       assert(false, red(e.message))
     rescue UsefulDB::EntryInDB => e
-      puts red(e.message) + green(" this is expected")
-      #puts e.backtrace
+      @log.info e.message + " this is expected"
     end
     
-    begin
-      puts "Write the DB structure back to disk"
-      UsefulDB.dbSave
-      UsefulDB.dbLoad
-      
-      puts "Check the total number of entries in the DB is still 2 " +
-      blue(assert_equal(2, UsefulDB.count).to_s)  
-    rescue UsefulDB::EmptyDB => e
-      assert(false, red(e.message))
-    end 
+    tempCount = startingCount + 1
+    @log.info "Check the total number of entries in the DB is still #{tempCount} " +
+    assert_equal(startingCount + 1, UsefulDB.count(@log)).to_s   
     
-    msg = "Test to check adding new element to the DB succeeds: "
     begin
-      entry2 = {"tag" => ["interesting", "gem", "website", "twitter"], "value" => "https://github.com/sferik/twitter/"}
-      puts "Creating another element" + entry2.inspect
+      @log.info "Write the DB structure back to disk and then reload"
+      UsefulDB.dbSave(@log)
+      UsefulDB.dbLoad(@log)
       
-      UsefulDB.add(entry2, {})
-      puts msg + blue(assert_equal(3, UsefulDB.count).to_s)
+      @log.info "Check the total number of entries in the DB is still #{tempCount} " +
+      assert_equal(startingCount + 1, UsefulDB.count(@log)).to_s
       
-    rescue UsefulDB::EntryInDB => e
-      assert(false, red(e.message))
-      #puts e.backtrace
-    rescue UsefulDB::EmptyDB => e
-      assert(false, red(e.message))
-    end
-        
-    puts green("test_add passed")
-  end
-
- 
-  # Test to check saving entries to the database
-  def test_save
-    puts yellow("\n## Executing test_save")
-    
-    msg = "Test to check adding new element to the DB succeeds: "
-    begin
-      entry = {"tag" => ["interesting", "gem", "website", "twitter"], "value" => "https://github.com/sferik/twitter/"}
-      puts "Creating another element" + entry.inspect
+      @log.info "Deleting this test entry from the database"
+      UsefulDB::remove(startingCount, @log)
       
-      UsefulDB.add(entry, {})
-      puts msg + blue(assert_equal(3, UsefulDB.count).to_s)  
-    rescue UsefulDB::EntryInDB => e
-      puts red(e.message) + green(" this is expected")
-      #puts e.backtrace
-    rescue UsefulDB::EmptyDB => e
-      assert(false, red(e.message))
-    end
-    
-    begin
-      puts "Saving the DB"
-      UsefulDB.dbSave
-      UsefulDB.dbLoad
-    
-      puts "Check the total number of entries in the DB is now 3 " +
-      blue(assert_equal(3, UsefulDB.count).to_s)  
-    rescue UsefulDB::EmptyDB => e
-      assert(false, red(e.message))
-    end
-
-    begin
-      UsefulDB.remove(2, {})
-      UsefulDB.dbSave
-    rescue UsefulDB::KeyOutOfBounds => e
-      assert(false, red(e.message))
-    rescue UsefulDB::EmptyDB => e
-      assert(false, red(e.message))
-    end
-
-    puts green("test_save passed")
-  end
-
-
-  # Test to check removal of entries from the database
-  def test_remove()
-    puts yellow("\n## Executing test_remove")
-
-    begin
-      puts "Test to check adding new element to the DB succeeds"
+      @log.info "Write the DB structure back to disk and then reload"
+      UsefulDB.dbSave(@log)
+      UsefulDB.dbLoad(@log)
       
-      entry = {"tag" => ["test"], "value" => "testvalue"}
-      entry2 = {"tag" => ["test2"], "value" => "testvalue2"}
-      puts "Creating another element" + entry.inspect + " and " + entry2.inspect
- 
-      UsefulDB.add(entry, {})
-      UsefulDB.add(entry2, {})
-    rescue UsefulDB::EntryInDB => e
-      assert(false, red(e.message))
-    end
-
-    begin
-      puts "Saving the DB"
-      UsefulDB.dbSave
-      UsefulDB.dbLoad
-
-      puts "Removing those 2 entries from the database"
-      UsefulDB.remove(2, {})
-      puts blue(assert_equal(3, UsefulDB.count))
-      UsefulDB.remove(2, {})
-      puts blue(assert_equal(2, UsefulDB.count))
-
-      puts "Saving the DB"
-      UsefulDB.dbSave
-    rescue UsefulDB::KeyOutOfBounds => e
-      assert(false, red(e.message))
+      @log.info "Check the total number of entries in the DB is back to #{startingCount} " +
+      assert_equal(startingCount, UsefulDB.count(@log)).to_s
     rescue UsefulDB::EmptyDB => e
       assert(false, red(e.message))
-    end
-
-    puts green("test_remove passed")
+    end 
+        
+    @log.info "test_add passed"
   end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: usefuldb
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-28 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,17 +68,17 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/usefuldb/utilities.rb
-- lib/usefuldb/settings.rb
+- lib/usefuldb.rb
 - lib/usefuldb/version.rb
 - lib/usefuldb/gui.rb
+- lib/usefuldb/utilities.rb
 - lib/usefuldb/exceptions.rb
-- lib/usefuldb.rb
+- lib/usefuldb/settings.rb
 - bin/usefuldb
-- README
 - COPYING
 - CHANGELOG
 - Rakefile
+- README
 - resources/db.yaml
 - test/main_test.rb
 homepage: http://rubygems.org/gems/usefuldb
@@ -104,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A simple commands and URLs database for storage of useful information