usefuldb 0.0.1

data/CHANGELOG

@@ -0,0 +1,18 @@
+usefuldb gem CHANGELOG
+
+## Version 0.0.1
+- Added test for adding entries to the database
+- Added test for removing entries from the database
+- Added test for loading and saving the database
+- Added executable script usefuldb, and the barebones parameter parsing system therein
+- Refactored the tests to allow for easier reading of the code
+- Updated the README to include information about dependencies and installation instructions
+- Wrapped all current codebase in a single Ruby module: UsefulDB
+- Added search functionality to the system
+- Added the functionality to add elements to the database
+- Added the functionality to list all elements in the database
+- Added functionality to delete an element from the database
+- On first run, the system will now install the database in the users home directory at ~/.usefuldb/db.yaml
+
+## Version 0.0.0
+- Added core functionality

data/COPYING

@@ -0,0 +1,4 @@
+usefuldb - simple commands and or urls database for storage of useful information.
+
+usefuldb is released under the creative commons attribution-sharealike 3.0 unported (cc by-sa 3.0) licence.
+for more information see: http://creativecommons.org/licenses/by-sa/3.0/

data/README

@@ -0,0 +1,13 @@
+## Readme
+
+### Dependencies
+In order to run the rake tests, you may require the following gems to be installed on your system:
+
+: rake
+: rack-test
+: test-unit
+
+
+### Install
+: rake test
+: rake install / sudo rake install

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => 'menu'
+
+task :menu do
+  puts welcomeMsg = <<-MSG
+rake build    # Build usefuldb-x.x.x.gem into the pkg directory
+rake install  # Build and install usefuldb-x.x.x.gem into system gems
+rake release  # Create tag vx.x.x and build and push usefuldb-x.x.x.gem to http://rubygems.org/
+rake test     # Run the unit testing suite on this gem.
+MSG
+end
+
+desc "Run the unit testing suite on this gem."
+task :test do
+  $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/lib')
+  require 'usefuldb.rb'
+  Dir.glob("./test/*_test.rb").each do |file|
+   require file
+  end
+end

data/bin/usefuldb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+require 'usefuldb'
+require 'optparse'
+
+#####################################################
+def addColour(text, colour_code)
+  "\e[#{colour_code}m#{text}\e[0m"
+end
+
+def red(text); addColour(text, 31); end
+def green(text); addColour(text, 32); end
+def yellow(text); addColour(text, 33); end
+def blue(text); addColour(text, 34); end
+#####################################################
+
+options = {}
+optparse = nil
+
+# Setup the system for use
+UsefulDB.setup
+
+begin
+  optparse = OptionParser.new do |opts|
+    
+    opts.banner = <<-WELCOME
+UsefulDB - a simple command and URL database
+
+   Useage:  usefuldb <searchtag1> <searchtag2> .. <searchtagN>
+
+WELCOME
+  
+    opts.on('-a', '--add', "Add an entry to the database") do |arg|
+      options[:a] = arg
+    end
+    
+    opts.on('-d', '--delete', "Delete an entry from the database") do |arg|
+      options[:d] = arg
+    end
+    
+    opts.on('-l', '--list', "List all entries in the database") do |arg|
+      options[:l] = arg
+    end
+    
+    opts.on('-v', '--verbose', "Runs the system in verbose mode") do |arg|
+      options[:v] = arg
+    end
+    
+    opts.on('-h', '--help', "Print out this message") do |arg|
+      puts opts
+      exit
+    end
+    
+  end.parse!
+rescue OptionParser::InvalidOption => e
+  puts e.message + "\n\nUseage: usefuldb -h or --help for help using the system"
+  exit()
+end
+
+#############################################################################
+
+# Checking for flag parameters
+if options.empty?
+  # No parameters of any kind were passed
+  if ARGV.empty?
+    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)
+  end
+
+# Some flags parameters were passed
+else
+  #puts options
+  
+  if options[:a] # The -a or --add flag check
+    puts green("Launching the add system:")
+    UsefulDB::GUI.add(options)
+  
+  elsif options[:l]
+    puts green("Launching the list system:")
+    UsefulDB::GUI.list
+    
+  elsif options[:d] # The -d or --delete flag check
+    puts "Run the delete system:"
+    UsefulDB::GUI.remove(options)
+    
+  end
+end
+
+

data/lib/usefuldb/exceptions.rb

@@ -0,0 +1,14 @@
+require 'usefuldb'
+
+module UsefulDB
+
+  class EntryInDB < Exception
+  end
+  
+  class EmptyDB < Exception
+  end
+  
+  class KeyOutOfBounds < Exception
+  end
+
+end

data/lib/usefuldb/gui.rb

@@ -0,0 +1,90 @@
+require 'usefuldb/utilities'
+
+module UsefulDB
+
+  class GUI
+    class << self
+      attr_accessor 
+       
+      def search(args)
+        UsefulDB.dbLoad
+        args.each {|i| puts "\n" + UsefulDB::UsefulUtils.search(i)} 
+      end
+      
+      def list
+        UsefulDB.dbLoad
+        UsefulDB::UsefulUtils.list.each_with_index do |i, index|
+          puts red(index)
+          puts "- Tags: " + yellow(i["tag"].to_s) + "\n"
+          puts "- Value: " + red(i["value"]) + blue("\n##\n")
+        end
+      end
+      
+      
+      def remove(opts)
+        if opts[:v] then puts "in verbose mode\n"; end
+        list()
+        
+        puts "Enter the number of the element from the list above which you want to delete"
+        value = STDIN.gets
+                
+        begin
+          UsefulDB.remove(value.to_i, {})
+          UsefulDB.dbSave
+        rescue KeyOutOfBounds => e
+          puts e.message + "\nexiting."
+          exit()
+        end
+        
+      end
+      
+       
+      def add(opts)
+        UsefulDB.dbLoad
+        if opts[:v] then puts "in verbose mode\n"; end
+        
+        puts "Please enter the comma separated search tags like the following:"
+        if opts[:v] then puts "eg:\nterm1, term2, term3\n\n"; end
+        
+        begin
+          tags = ((STDIN.gets).strip).split(', ')
+          puts "The following was captured: " + tags.to_s
+          puts "Is this correct? y/n"
+          
+          input = (STDIN.gets).strip
+          if input == "y"
+            puts "Please enter the value you wish to store for this database entry:"
+            value = (STDIN.gets).strip
+            
+            puts "The following was captured: " + value
+            puts "Is this correct? y/n"
+            input = (STDIN.gets).strip
+            if input == "y"
+              entry = {"tag" => tags, "value" => value}
+              
+              if opts[:v] then puts "Storing the following in the database:\n" + entry.to_s; end
+              
+              UsefulDB.add(entry, {})
+              UsefulDB.dbSave
+              
+            else
+              puts "Exiting"
+              exit
+            end
+          else
+            puts "Exiting"
+            exit
+          end
+          
+        rescue Exception => e
+          puts e.message
+          exit
+        end
+        
+      end
+    
+    
+    end
+  end
+
+end

data/lib/usefuldb/settings.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+
+module UsefulDB
+
+  class Settings
+    class << self
+  
+      attr_accessor :data
+      
+      def load(path)
+        @data = begin
+          YAML.load(File.open(path))
+        rescue ArgumentError => e
+          exit("Could not parse YAML: #{e.message}")
+        end  
+      end
+      
+      def save(newData, path)
+        @data = newData
+        f = File.open(path, "w")
+        f.write(@data.to_yaml)
+        f.close
+      end
+  
+    end
+  end
+
+end

data/lib/usefuldb/utilities.rb

@@ -0,0 +1,108 @@
+require 'usefuldb/exceptions'
+
+module UsefulDB
+
+  class UsefulUtils
+    class << self
+    
+      attr_accessor :data, :dbpath
+      
+      #####################################################
+      def addColour(text, colour_code)
+        "\e[#{colour_code}m#{text}\e[0m"
+      end
+      
+      def red(text); addColour(text, 31); end
+      def green(text); addColour(text, 32); end
+      def yellow(text); addColour(text, 33); end
+      def blue(text); addColour(text, 34); end
+      #####################################################
+      
+      
+      # Save the database to disk
+      def dbSave()
+        if @dbpath.nil?
+          #@dbpath = File.expand_path(File.dirname(__FILE__) + '/../../resources/db.yaml')
+          @dbpath = ENV['HOME'] + "/.usefuldb/db.yaml"
+          Settings.save(@data, @dbpath)
+        else
+          Settings.save(@data, @dbpath)
+        end
+      end
+      
+      
+      # Load the database from disk
+      def dbLoad()
+        #@dbpath = File.expand_path(File.dirname(__FILE__) + '/../../resources/db.yaml')
+        @dbpath = ENV['HOME'] + "/.usefuldb/db.yaml"
+        Settings.load(dbpath)
+        @data = Settings.data
+      end
+      
+      
+      # Return the number of elements in the database.
+      def count()
+        if @data.count == 0
+          raise EmptyDB, "The DB is currently empty."
+        else
+          return @data.count
+        end
+      end
+      
+      
+      # Add an element to the database
+      def add(hash, opts)
+        if @data.include?(hash) then raise EntryInDB, "Entry already in the DB"; else @data << hash; end    
+      end
+  
+      
+      # Remove an element from the database
+      def remove(key, opts)
+        if @data.count == 0
+          raise EmptyDB, "You cannot call the remove function on an empty Database!"
+        elsif @data.count < key || key < 0
+          raise KeyOutOfBounds, "Key does not exist in the DB"
+        else
+          @data.delete_at(key) 
+        end
+      end
+      
+      
+      # Setup the system for the first time
+      def setup()
+        resourceDir = ENV['HOME'] + "/.usefuldb/"
+        if File.directory?(resourceDir) 
+          # The folder already exists, do nothing
+        else
+          # We need to create this folder and install the DB there.
+          FileUtils.mkdir(resourceDir)
+          dbpath = File.expand_path(File.dirname(__FILE__) + '/../resources/db.yaml')
+          FileUtils.cp(dbpath, resourceDir)
+        end
+      end
+      
+      
+      # Search for a tag in the DB
+      def search(tag)
+        msg = "Searching the database for tag: " + yellow(tag) + "\n"
+        
+        @data.each do |db|
+          if db["tag"].include?(tag)
+            msg += "- Tags: " + db["tag"].to_s + "\n"
+            msg += "- Value: " + db["value"] + blue("\n##\n")
+          end
+        end
+        return msg
+      end
+      
+      
+      # List out all elements in the DB
+      def list
+        return @data
+      end
+      
+  
+    end
+  end
+
+end

data/lib/usefuldb.rb

@@ -0,0 +1,39 @@
+require 'usefuldb/settings'
+require 'usefuldb/utilities'
+require 'usefuldb/exceptions'
+require 'usefuldb/gui'
+require 'fileutils'
+
+module UsefulDB
+  class << self
+        
+    def add(hash, opts)
+      UsefulDB::UsefulUtils.add(hash, opts)
+    end
+  
+    def count()
+      UsefulDB::UsefulUtils.count
+    end
+    
+    def remove(key, opts)
+      UsefulDB::UsefulUtils.remove(key, opts)
+    end
+    
+    def dbSave
+      UsefulDB::UsefulUtils.dbSave
+    end
+    
+    def dbLoad
+      UsefulDB::UsefulUtils.dbLoad
+    end
+    
+    def search(args)
+      return UsefulDB::UsefulUtils.search(args)
+    end
+    
+    def setup
+      UsefulDB::UsefulUtils.setup
+    end
+
+  end
+end

data/resources/db.yaml

@@ -0,0 +1,13 @@
+---
+- tag:
+  - install
+  - rubygems
+  - website
+  - usefuldb
+  value: http://rubygems.org/usefuldb
+- tag:
+  - search
+  - find
+  - website
+  - google
+  value: http://www.google.com

data/test/main_test.rb

@@ -0,0 +1,166 @@
+require 'test/unit'
+require 'rack/test'
+require 'fileutils'
+require 'usefuldb'
+
+ENV['RACK_ENV'] = 'test'
+
+#####################################################
+def addColour(text, colour_code)
+  "\e[#{colour_code}m#{text}\e[0m"
+end
+
+def red(text); addColour(text, 31); end
+def green(text); addColour(text, 32); end
+def yellow(text); addColour(text, 33); end
+def blue(text); addColour(text, 34); end
+#####################################################
+
+
+class UsefulDBTest < Test::Unit::TestCase
+
+  include Rack::Test::Methods
+  
+  def setup
+    UsefulDB.dbLoad
+  end
+
+  #def teardown
+  #  UsefulUtils.dbSave
+  #end
+
+
+  # Test to check adding of entries to the database
+  def test_add
+    puts yellow("## Executing test_add")
+  
+    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, {})
+      
+    rescue UsefulDB::EmptyDB => e
+      assert(false, red(e.message))
+    rescue UsefulDB::EntryInDB => e
+      puts red(e.message) + green(" this is expected")
+      #puts e.backtrace
+    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 
+    
+    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
+      
+      UsefulDB.add(entry2, {})
+      puts msg + blue(assert_equal(3, UsefulDB.count).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
+      
+      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"
+      
+      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))
+    rescue UsefulDB::EmptyDB => e
+      assert(false, red(e.message))
+    end
+
+    puts green("test_remove passed")
+  end
+
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: usefuldb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- David Kirwan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rack-test
+  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: usefuldb is a simple database which is designed to store useful commands
+  and URLs
+email:
+- 00346128@mail.wit.ie
+executables:
+- usefuldb
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/usefuldb.rb
+- lib/usefuldb/utilities.rb
+- lib/usefuldb/exceptions.rb
+- lib/usefuldb/gui.rb
+- lib/usefuldb/settings.rb
+- bin/usefuldb
+- Rakefile
+- CHANGELOG
+- COPYING
+- README
+- resources/db.yaml
+- test/main_test.rb
+homepage: http://rubygems.org/gems/usefuldb
+licenses:
+- CC BY-SA 3.0
+post_install_message: ! 'usefuldb - simple commands and or urls database for storage
+  of useful information.
+
+
+  usefuldb is released under the creative commons attribution-sharealike 3.0 unported
+  (cc by-sa 3.0) licence.
+
+  for more information see: http://creativecommons.org/licenses/by-sa/3.0/
+
+'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+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: A simple commands and URLs database for storage of useful information
+test_files: []