Tracker 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright (c) 2006 Hugh Bien
+
+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

@@ -0,0 +1,18 @@
+== Using tracker (or whatever it's named)
+  tracker help
+  Can be used with alternative file, use the -f option.
+  tracker -f /path/to/sqlite3_file
+  
+== Dependencies
+  Ruby 1.8
+  SWIG
+  SQLite3
+  SQLite3-Ruby interface
+  
+== To add a new action
+  * Implement it in Bug class (for whatever bug needs that doesn't have)
+  * Add the command to the factory in lib/factory.rb
+  * Make sure the options are valid.  You can add new options in the hash in tracker.rb.
+  
+== LICENSE
+See MIT-LICENSE.

data/bin/fixture.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+require "rubygems"
+require_gem "activerecord"
+
+# Load the fixtures file and database
+fixtures_file = ARGV[0] || "tests/fixtures.yml"
+database = ARGV[1] || ".tracker_db"
+
+# Load the YAML information
+yaml = YAML.load_file(fixtures_file)
+
+# Connect to the database file
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => database
+)
+
+class Bug < ActiveRecord::Base
+end
+
+class BugDescription < ActiveRecord::Base
+end
+
+class String
+  def to_constant
+    return Bug if self == "Bug"
+    return BugDescription if self == "BugDescription"
+  end
+end
+
+yaml.each_pair do |key, value|
+  key.to_constant.create( value )
+end
+
+

data/bin/package

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+cd lib
+cat *.rb >> final_package
+mv final_package ..
+cd ..
+cat tracker >> final_package
+sed -e 's/^require.*$//g' final_package > temp
+rm final_package
+cat lib/requires temp > final_package
+rm temp
+chmod a+x final_package

data/bin/trac

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# Tracker is under the MIT-LICENSE
+# Please see http://ieng6.ucsd.edu/~hbien/tracker for more information about Tracker.
+
+# Handles connection to the database
+
+require "rubygems"
+require_gem "Tracker"
+
+# The default database file_name
+DEFAULT_DATABASE_FILE_NAME = ".tracker_db"
+
+# -----------------------------------------------------------------------------
+# Begin executing the script here.
+# -----------------------------------------------------------------------------
+
+# What file should we use for the database?
+database = DEFAULT_DATABASE_FILE_NAME
+
+# What to do if no database can be found
+def no_database_error(database_file = "the current")
+  puts "Could not find '.tracker_db' in #{database_file} or any parent directories."
+  puts "Try '#{File.basename(__FILE__)} create' to create a new database in the current directory or '#{File.basename(__FILE__)} help' to see available commands."
+  exit
+end
+
+# Is the user creating a new database?
+if ARGV.include?("create") 
+  if File.exists?(database)
+    puts "A '.tracker_db' database already exists in the current directory.  Try removing it to create a new one."
+    exit
+  else
+    Database::create_database(database)
+    exit
+  end
+end
+
+# Find the database in parent directories
+iteration = 0
+while !File.exists?(database) && iteration < 10
+  iteration += 1
+  database = File.join("..", database)
+end
+
+# Could we find the database?
+if iteration == 10 && !ARGV.include?("help") && !ARGV.include?("--file") && !ARGV.include?("-f")
+  no_database_error
+else
+  if ARGV.include?("-f") || ARGV.include?("--file")
+    index = ARGV.index("-f") + 1 if ARGV.include?("-f")
+    index = ARGV.index("--file") + 1 if ARGV.include?("--file")
+    database = ARGV[index]
+    database = File.join(database, ".tracker_db") if File.directory?(database)
+    no_database_error(database) if !File.exist?(database)
+  end
+  # if we did, execute command
+  Database::connect_to_database(database)
+  parser = Interface.new
+  begin
+    parser.parse_command(ARGV)
+  rescue Exception => error
+    puts "Error executing database instructions: " + error
+  end
+end
+

data/db/migrate

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require_gem "activerecord"
+
+puts "Removing the database..."
+`rm .tracker_db` if File.exists?(".tracker_db")
+
+# Connect to the database
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3", 
+  :database => ".tracker_db"
+)
+
+# Create the bugs table
+ActiveRecord::Schema.define do
+  create_table "bugs" do |t|
+    t.column "name", :string
+    t.column "priority", :int
+    t.column "area", :string
+    t.column "status", :boolean, :default => false
+    t.column "date_time", :date_time
+  end
+end
+
+# Creates the bug_descriptions
+ActiveRecord::Schema.define do
+  create_table "bug_descriptions" do |t|
+    t.column "bug_id", :int
+    t.column "date_time", :date_time
+    t.column "description", :text
+  end
+end
+
+class Bug < ActiveRecord::Base
+  has_many :bug_descriptions
+end
+
+class BugDescription < ActiveRecord::Base
+  belongs_to :bugs
+end
+
+puts "Populating database with test data..."
+yesterday = 1.day.ago.to_s(:db)
+today = Time.now.to_s(:db)
+tomorrow = 1.day.from_now.to_s(:db)
+
+# Add test data to the database
+bug = Bug.create(:name => "First", :priority => 1, :area => "One", :date_time => yesterday, :status => true)
+bug.bug_descriptions.create(:date_time => yesterday, :description => "First description.\n")
+bug.bug_descriptions.create(:date_time => today, :description => "Second description.\n")
+bug.bug_descriptions.create(:date_time => today, :description => "Third description.\n")
+
+bug = Bug.create(:name => "Second", :priority => 2, :area => "Two", :date_time => today, :status => true)
+bug.bug_descriptions.create(:date_time => yesterday, :description => "First description.\n")
+bug.bug_descriptions.create(:date_time => today, :description => "Second description.\n")
+bug.bug_descriptions.create(:date_time => today, :description => "Third description.\n")
+
+bug = Bug.create(:name => "Third", :priority => 3, :area => "Three", :date_time => tomorrow)
+bug.bug_descriptions.create(:date_time => yesterday, :description => "First description.\n")
+bug.bug_descriptions.create(:date_time => today, :description => "Second description.\n")
+bug.bug_descriptions.create(:date_time => today, :description => "Third description.\n")
+
+bug = Bug.create(:name => "Fourth", :priority => 4, :area => "Four", :date_time => tomorrow)
+bug.bug_descriptions.create(:date_time => yesterday, :description => "First description.\n")
+bug.bug_descriptions.create(:date_time => today, :description => "Second description.\n")
+bug.bug_descriptions.create(:date_time => today, :description => "Third description.\n")
+
+
+

data/lib/action.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + "/bug.rb"
+require File.dirname(__FILE__) + "/helper.rb"
+
+# The Action module is just a simple interface for the Bug class.  Use this instead of using the Bug class directly, it should satisfy all actions needed to CRUD from the bugs database.
+module Action
+  # Adds a new description to an existing bug.  Used when a user wants to add new information found about a bug.  Takes a hash as parameter where one item is either :name or :id and the other is :description
+  def self.append_description(hash)
+    return nil if hash[:description] =~ /^\s*$/ # Returns nil if no description given
+    bug = Bug.search(hash)
+    bug.bug_descriptions.create(:description => hash[:description]) 
+  end
+  
+  # Closes the bug from being listed.
+  def self.close_bug(hash)
+    bug = Bug.search(hash)
+    bug.update_attributes(:status => true)
+  end
+  
+  # Delets the bug with the given id/name and associated bug descriptions
+  def self.delete_bug(hash)
+    bug = Bug.search(hash)
+    bug.destroy
+  end
+
+  # Lists all of the open bugs by whatever conditions are meant
+  # The intersection of the conditions are returned
+  # By default, status is false
+  def self.list_bugs(hash = Hash.new)
+    hash[:status] = false unless hash.has_key?(:status)
+    bugs = Bug.find(:all, :conditions => Helper::hash_to_sql(hash), :order => "priority DESC, date_time")
+    return bugs
+  end
+  
+  # Takes a hash as a parameter which is the data for the bug.
+  #   * name - Descriptive name used for searching
+  #   * priority - an integer, 1 being the highest priority, as large a number as you want.
+  #   * area - Area, can be the filename, classname, or programmer name, etc.
+  #   * description - Quick description, what was expected, what actually happened, and how to reproduce the bug.
+  def self.new_bug(hash)
+    description = hash[:description]
+    hash.delete(:description)
+    bug = Bug.create(hash)
+    bug.bug_descriptions.create(:description => description)
+    return bug
+  end
+  
+  # Opens a bug to be listed.
+  def self.open_bug(hash)
+    bug = Bug.search(hash)
+    bug.update_attributes(:status => false)
+  end
+
+  # Updates the given bug with new information
+  def self.update_bug(hash)
+    bug = Bug.search(hash)
+    bug.update_attributes(hash)
+  end
+  
+  # Returns all of the areas for the open bugs
+  def self.list_areas(*args)
+    # Find all open bugs
+    bugs = list_bugs(*args)
+    
+    # Get all of the unique areas from the bugs
+    areas = bugs.collect { |bug| bug.area }
+    return areas.uniq
+  end
+  
+  # Returns all of the names of the open bugs
+  def self.list_names(*args)
+    # Find all open bugs
+    bugs = list_bugs(*args)
+    
+    # Get all of the uniqe names from the bugs
+    names = bugs.collect { |bug| bug.name }
+    return names.uniq
+  end
+end
+

data/lib/bug.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require_gem 'activerecord'
+
+# Fields are name (string), priority (int), area (string), status (boolean).
+class Bug < ActiveRecord::Base
+  has_many :bug_descriptions, :exclusively_dependent => true
+  before_create :save_date_time
+  before_update :save_date_time
+
+  # Is the bug open?
+  def open?
+    !status
+  end
+  
+  # Is the bug closed?
+  def closed?
+    status
+  end
+  
+  # Searches for a bug with given name or id
+  def self.search(term=nil)
+    # Get the needed search term if the argument is a hash
+    term = self.get_term(term) if term.kind_of?(Hash)
+    
+    # Find the right bug
+    bug = self.get_bug_from_id_or_name(term)
+    
+    # What to do if the bug isn't found
+    if bug == nil
+      raise Exception, "Bug not found with name '#{term}'." if term.kind_of?(String)
+      raise Exception, "Bug not found with id \##{term}." if term.kind_of?(Fixnum)
+    end
+    
+    # Return the bug
+    return bug
+  end
+  
+  private
+  # Makes sure the time is saved whenever a bug is saved or modified
+  def save_date_time
+    self.date_time = Time.now.to_s(:db)
+  end
+    
+  # Gets the term (name or id) out of a hash
+  def self.get_term(hash)
+    term = hash[:name] if hash.has_key?(:name)
+    term = hash[:id] if hash.has_key?(:id)
+    return term
+  end
+  
+  # Get the bug when given an id or name
+  def self.get_bug_from_id_or_name(search_key)
+    if search_key.kind_of?(String)
+      bug = find_by_name(search_key)
+    elsif search_key.kind_of?(Fixnum)
+      bug = find_by_id(search_key)
+    end
+    return bug
+  end
+    
+  alias_method :opened?, :open?
+  
+end

data/lib/bug_description.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require_gem 'activerecord'
+
+# Fields are bug_id (int), date (date), description (text).
+class BugDescription < ActiveRecord::Base
+  belongs_to :bug
+  before_save :save_date_time
+  before_update :save_date_time
+  
+  private
+  # Saves date_time as current time
+  def save_date_time
+    self.date_time = Time.now.to_s(:db)
+  end
+end

data/lib/database.rb

@@ -0,0 +1,44 @@
+require "rubygems"
+require_gem "activerecord"
+
+# This module handles the connection to a database.  There are only two methods, one to connect, one to create (connect_to_database and create_database, repsectively).
+module Database
+    
+  # This method should be called when starting the script to connect the program
+  # to the database.
+  def self.connect_to_database(database)
+    # Start the script by connecting to the sqlite3 datbase
+    ActiveRecord::Base.establish_connection(
+      :adapter => "sqlite3", 
+      :database => database
+    )
+  end
+  
+  # If no database currently exists, this method will create one using
+  # ActiveRecord's migrations
+  def self.create_database(database)
+    puts "Creating database '#{database}' in current directory..."
+    connect_to_database(database)
+    
+    # Creates the bugs table
+    ActiveRecord::Schema.define do
+      create_table "bugs" do |t|
+        t.column "name", :string
+        t.column "priority", :int
+        t.column "area", :string
+        t.column "status", :boolean, :default => false
+        t.column "date_time", :datetime
+      end
+    end
+    
+    # Creates the bug_descriptions
+    ActiveRecord::Schema.define do
+      create_table "bug_descriptions" do |t|
+        t.column "bug_id", :int
+        t.column "date_time", :datetime
+        t.column "description", :text
+      end
+    end
+  end
+
+end

data/lib/helper.rb

@@ -0,0 +1,16 @@
+# This module includes static methods that do not fall into cateogries.  These are just helper methods for various algorithms throughout the source code.
+module Helper
+
+  # Takes a hash and returns the conditions sql for an ActiveRecord find method
+  def self.hash_to_sql(hash)
+    conditions = Array.new
+    hash.each do |attribute, term|
+      conditions << "#{attribute} = ?"
+    end
+    sql_string = conditions.join(" and ")
+    sql = [sql_string]
+    hash.each { |attribute, term| sql << term }
+    return sql
+  end
+  
+end

data/lib/interface.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + "/prompter.rb"
+require File.dirname(__FILE__) + "/database.rb"
+require File.dirname(__FILE__) + "/action.rb"
+require File.dirname(__FILE__) + "/bug.rb"
+require File.dirname(__FILE__) + "/bug_description.rb"
+
+# The Interface's job is to act as the interface between the user and the Action module.  The Interface will make sure that messages are outputted to the user and pass along actions to the Action module depending on whatever the command is.
+class Interface
+    
+  # Let the tracker interface have access to the bugger - controller
+  def initialize()
+    @filename = File.basename(__FILE__)
+    @all_options = ["name", "priority", "area", "description"]
+  end
+  
+  # Parses ARGV and executes the correct bugger operations
+  # Will print out to the user whatever the user requested
+  def parse_command(command_line_arguments)
+    # Parse the command
+    hash = args_to_hash(command_line_arguments)
+    command = command_line_arguments[0]
+    if command_line_arguments.size > 1 && command_line_arguments[1][0,1] != "-"
+      get_name_or_id(command_line_arguments[1], hash)
+    end
+    
+    # Perform the correct action for whatever command it is
+    if command.include?("append")       # Appends a description to existing bug
+      hash = include_name_or_id(hash)
+      hash[:description] = Prompter.description? if !hash.has_key?(:description)
+      Action::append_description(hash)
+    elsif command.include?("areas")
+      puts "Searched ticket areas are:"
+      Action::list_areas(hash).each { |area| puts " * " + area }
+    elsif command.include?("names")
+      puts "Searched ticket names are:"
+      Action::list_names(hash).each { |name| puts " * " + name }
+    elsif command.include?("close")     # Closes an existing bug
+      hash = include_name_or_id(hash)
+      Action::close_bug(hash)
+    elsif command.include?("delete")    # Deletes the bug from the database
+      hash = include_name_or_id(hash)
+      Action::delete_bug(hash)
+    elsif command.include?("list")      # Lists either all open bugs or bugs by conditions
+      bugs = Action::list_bugs(hash)
+      puts bugs.collect { |bug| get_print_info(bug) }.join("\n") if bugs.size > 0
+    elsif command.include?("new")       # Creates a new bug
+      set_options(@all_options, hash)
+      Action::new_bug(hash)
+    elsif command.include?("open")      # Opens a closed bug
+      hash = include_name_or_id(hash)
+      Action::open_bug(hash)
+    elsif command.include?("update")
+      hash = include_name_or_id(hash)
+      Action::update_bug(hash)
+    elsif command.include?("help") || command.include?("--help") # Prints usage
+      print_usage
+    else
+      puts "Try '#{@filename} help'."
+    end
+  end
+  
+          
+  private
+  # Changes ARGV into a hash, ie. trac --name NAME --priority 2 becomes {:name => "NAME", :priority => 2}
+  def args_to_hash(args)
+    hash = Hash.new
+    hash[:id] = args[args.index("--id") + 1].to_i if args.include?("--id")
+    hash[:id] = args[args.index("-i") + 1].to_i if args.include?("-i")
+    hash[:name] = args[args.index("--name") + 1] if args.include?("--name")
+    hash[:name] = args[args.index("-n") + 1] if args.include?("-n")
+    hash[:priority] = args[args.index("--priority") + 1].to_i if args.include?("--priority")
+    hash[:priority] = args[args.index("-p") + 1].to_i if args.include?("-p")
+    hash[:area] = args[args.index("--area") + 1] if args.include?("--area")
+    hash[:area] = args[args.index("-a") + 1] if args.include?("-a")
+    hash[:description] = args[args.index("--description") + 1] if args.include?("--description")
+    hash[:description] = args[args.index("-d") + 1] if args.include?("-d")
+    hash[:status] = false if args.include?("--open") or args.include?("-o")
+    hash[:status] = true if args.include?("--closed") or args.include?("-c")
+    return hash
+  end
+    
+  # Inspects the hash 'given' to see if it has the 'needed' keys.  If it doesn't,
+  # will prompt the user for items.
+  def set_options(needed, given)
+    needed.each do |item|
+      if !given.has_key?(item.to_sym)
+        given[item.to_sym] = Prompter.send(item+"?")
+      end
+    end
+    return given
+  end
+  
+  # If the given hash doesn't include an :id or :name key, prompts the user for
+  # an :id key and inserts it into the hash
+  def include_name_or_id(hash)
+    return hash if hash.has_key?(:name) or hash.has_key?(:id)
+    hash[:id] = Prompter.id?
+    return hash
+  end
+  
+  # Determines if a given argument is an id or name and includes it in a hash as
+  # long as no other id or name was already included in the hash
+  def get_name_or_id(name_or_id, hash = Hash.new)
+    hash[:id] = name_or_id.to_i if name_or_id.to_i.kind_of?(Fixnum) && !hash.has_key?(:name) && name_or_id.to_i != 0
+    hash[:name] = name_or_id if name_or_id.kind_of?(String) && !hash.has_key?(:id)
+    return hash
+  end
+     
+  # Returns the info for a bug to be printed out to the user
+  def get_print_info(bug)
+    working_string = String.new
+    working_string << "Ticket(#{bug.id}):    #{bug.name}\n" if bug.id < 10
+    working_string << "Ticket(#{bug.id}):   #{bug.name}\n" if bug.id >= 10 && bug.id < 100
+    working_string << "Ticket(#{bug.id}):  #{bug.name}\n" if bug.id >= 100
+    working_string << "Priority:     #{bug.priority}\n"
+    working_string << "Area:         #{bug.area}\n"
+    working_string << "Description - #{bug.date_time.to_s(:short)}:\n"
+    descriptions = bug.bug_descriptions.collect { |desc| " * " + desc.description }.join
+    working_string << descriptions
+    return working_string
+  end
+  
+  # Prints a description out
+  def print_description(description)
+    puts description.description # The description method
+    puts "-"
+  end
+  
+  # Tracker's usage
+  def print_usage 
+    puts "usage: #{@filename} <command> [options] [-f DIRECTORY | DATABASE]"
+    puts ""
+    puts "Available commands:"
+    puts "  create"
+    puts "  append [-i ID | -n NAME | -d DESCRIPTION]"
+    puts "  close  [-i ID | -n NAME]"
+    puts "  delete [-i ID | -n NAME]"
+    puts "  list   [-i ID | -n NAME | -p PRIORITY | -a AREA | -c | -o]"
+    puts "  help"
+    puts "  new    [-n NAME | -p PRIORITY | -a AREA | -d DESCRIPTION]"
+    puts "  open   [-i ID | -n NAME]"
+    puts "  update [-i ID | -n NAME | -p PRIORITY | -a AREA]"
+    puts "  areas  [-n NAME | -p PRIORITY | -c | -o]"
+    puts "  names  [-a AREA | -p PRIORITY | -c | -o]"
+    puts ""
+    puts "Available options:"
+    puts "  -i ID | --id ID"
+    puts "  -n NAME | --name NAME"
+    puts "  -p PRIORITY | --priority PRIORITY"
+    puts "  -a AREA | --area AREA"
+    puts "  -d DESCRIPTION | --description DESCRIPTION"
+    puts "  -c | --closed"
+    puts "  -o | --open"
+    puts "  -f FILE | --file FILE"
+    puts ""
+    puts "Tracker is a command-line client for a bugs/features database.  The database is kept in a flat file '.tracker_db' in the current directory."
+    puts ""
+    puts "To create a '.tracker_db' file, try using '#{@filename} create'."
+  end
+  
+end

data/lib/prompter.rb

@@ -0,0 +1,66 @@
+# Prompts the user for information.  All prompts are contained into this class.  All methods are class methods.
+class Prompter
+  
+  # Asks for id
+  def self.id?
+    self.int("id")
+  end
+  
+  # Asks for area
+  def self.area?
+    self.string("area")
+  end
+  
+  # Ask for priority - int
+  def self.priority?
+    self.int("priority")
+  end
+  
+  # Asks for a name
+  def self.name?
+    self.string("name")
+  end
+  
+  # Asks for description.  Terminate with ^d on empty line.
+  def self.description?
+    self.text("description")
+  end
+  
+  private
+  # Prompt for a string
+  def self.string(term)
+    print term.capitalize + ": " 
+    STDIN.gets.gsub("\n", "")
+  end
+  
+  # Prompt for an int
+  def self.int(term)
+    print term.capitalize + ": "
+    STDIN.gets.to_i
+  end
+  
+  # Prompt for text.  Terminate with ^d on empty line.
+  def self.text(term)
+    # Create the method
+    puts term.capitalize + ":"
+    text = String.new
+    string = STDIN.gets
+    while string
+      text += string
+      string = STDIN.gets
+    end
+    return text
+  end
+  
+  # Prompt for a yes or no.
+  def self.boolean(term)
+    print term.capitalize + ": "
+    string = STDIN.gets
+    if string.include?("Y") || string.include?("y")
+      return true
+    else
+      return false
+    end
+  end
+            
+end

data/tests/fixtures.yml

@@ -0,0 +1,3 @@
+Bug:
+  name: Test
+  

data/tests/tc_action.rb

@@ -0,0 +1,135 @@
+require "test/unit"
+
+require File.dirname(__FILE__) + "/../lib/action.rb"
+require File.dirname(__FILE__) + "/../lib/database.rb"
+require File.dirname(__FILE__) + "/../lib/bug_description.rb"
+
+class TestBugger < Test::Unit::TestCase
+  def setup
+    Database::connect_to_database(".tracker_db")
+    @bug_names = ["First", "Second", "Third", "Fourth"]
+    @bug_ids = [1, 2, 3, 4]
+    @bug_priorities = [1, 2, 3, 4]
+    @bug_areas = ["One", "Two", "Three", "Four"]
+    @bug_status = [true, true, false, false]
+    @descriptions = ["First description", "Second description", "Third description"]
+  end
+  
+  def teardown
+    # Delete all bugs that aren't in the migration
+    bugs = Bug.find(:all)
+    bugs.delete_if { |bug| @bug_ids.include?(bug.id) }
+    bugs.each { |bug| bug.destroy }
+  end  
+
+  def test_append_description
+    bug = Bug.create(:name => "test_append_description", :priority => 1, :area => "none")
+    Action::append_description(:id => bug.id, :description => "Hello")
+    Action::append_description(:name => "test_append_description", :description => "World")
+    assert_equal(bug.bug_descriptions[0].description, "Hello")
+    assert_equal(bug.bug_descriptions[1].description, "World")
+  end
+  
+  # An empty description should NOT be appened.
+  def test_append_description_that_is_empty
+    bug = Bug.create(:name => "test_append_empty_description", :priority => 1, :area => "none")
+    descriptions_to_test = ["", " ", "  ", "\n", "\n\n", " \n ", "\n ", " \n"]
+    descriptions_to_test.each do |string|
+      Action::append_description(:name => "test_append_empty_description", :description => string)
+    end
+    bug = Bug.find(bug.id)
+    assert_equal(0, bug.bug_descriptions.size)
+  end
+  
+  def test_close_bug
+    bug = Bug.find_by_status(false)
+    Action::close_bug(:id => bug.id)
+    bug = Bug.find_by_id(bug.id)
+    assert(bug.closed?)
+    bug.status = false
+    bug.save
+  end
+  
+  def test_delete_bug
+    bug = Bug.create(:name => "test_delete_bug", :priority => 2, :area => "none")
+    Action::delete_bug(:name => "test_delete_bug")
+    assert(!Bug.find_by_name("test_delete_bug"))
+  end
+  
+  def test_list_bugs
+    bugs = Action::list_bugs
+    bugs.each { |bug| assert(@bug_names.include?(bug.name)) }
+    bugs = Action::list_bugs(:name => "First")
+    assert_equal(0, bugs.size)
+    bugs = Action::list_bugs(:status => false)
+    assert_equal(2, bugs.size)
+  end
+  
+  # Make sure the listed bugs with a condition are ALL opened
+  def test_open_list_bugs
+    first = Bug.create(:name => "Another open bug", :area => "Four")
+    second = Bug.create(:name => "Another closed bug", :area => "Four", :status => true)
+    bugs = Action::list_bugs(:area => "Four")
+    bugs.each { |bug| assert(bug.open?) }
+  end
+  
+  def test_new_bug
+    bug = Action::new_bug(:name => "test_new_bug", :priority => 1, :area => "none", :description => "This is a test description")
+    assert(bug)
+    assert(Bug.find_by_name("test_new_bug"))
+    assert_equal(Bug.find_by_name("test_new_bug").name, "test_new_bug")
+    assert_equal(bug.bug_descriptions[0].description, "This is a test description")
+  end
+  
+  def test_open_bug
+    bug = Bug.find_by_status(true)
+    Action::open_bug(:id => bug.id)
+    bug = Bug.find_by_id(bug.id)
+    assert(bug.open?)
+    bug.status = true
+    bug.save
+  end
+  
+  def test_update_bug
+    bug = Bug.create(:name => "test_update_bug", :priority => 1, :area => "none")
+    assert(bug)
+    Action::update_bug(:id => bug.id, :name => "new_name", :priority => 2, :area => "Nothing")
+    bug = Bug.find_by_id(bug.id)
+    assert_equal("new_name", bug.name)
+    assert_equal("Nothing", bug.area)
+    assert_equal(2, bug.priority)
+  end
+  
+  # Should list all _open_ areas
+  def test_list_areas
+    areas = Action::list_areas
+    known_areas = ["Four", "Three"]
+    areas.each { |area| assert(known_areas.include?(area)) }
+  end
+  
+  # Should list all bug areas with the condition given
+  def test_list_areas_with_conditions
+    areas = Action::list_areas(:name => "Fourth")
+    assert_equal("Four", areas[0])
+    areas = Action::list_areas(:priority => 3)
+    assert_equal("Three", areas[0])
+  end
+  
+  # Should list all _open_ bug names
+  def test_list_names
+    names = Action::list_names
+    known_names = ["Fourth", "Third"]
+    names.each { |name| assert(known_names.include?(name)) }
+  end
+  
+  # Should list all  _open_ bug names with the conditions given
+  def test_list_names_with_conditions
+    names = Action::list_names(:name => "Third")
+    assert_equal("Third", names[0])
+    names = Action::list_names(:priority => 2)
+    assert_equal(nil, names[0])
+    names = Action::list_names(:priority => 2, :status => true)
+    assert_equal("Second", names[0])
+  end
+  
+end

data/tests/tc_bug.rb

@@ -0,0 +1,65 @@
+require "test/unit"
+
+require File.dirname(__FILE__) + "/../lib/bug.rb"
+
+class TestBug < Test::Unit::TestCase
+  def setup
+    Database::connect_to_database(".tracker_db")
+    @bug_names = ["First", "Second", "Third", "Fourth"]
+    @bug_ids = [1, 2, 3, 4]
+    @bug_priorities = [1, 2, 3, 4]
+    @bug_areas = ["One", "Two", "Three", "Four"]
+    @bug_status = [true, true, false, false]
+    @descriptions = ["First description", "Second description", "Third description"]
+  end
+  
+  def teardown
+  end  
+
+  def test_open?
+    bug = Bug.find_by_name("Third")
+    assert(bug.open?)
+    assert(!bug.closed?)
+  end
+  
+  def test_closed?
+    bug = Bug.find_by_name("First")
+    assert(bug.closed?)
+    assert(!bug.open?)
+  end
+  
+  def test_search_by_name
+    @bug_names.each do |name|
+      bug = Bug.search(name)
+      assert_equal(name, bug.name)
+    end
+  end
+  
+  def test_search_by_id
+    4.times do |i|
+      bug = Bug.search(@bug_ids[i])
+      assert_equal(@bug_names[i], bug.name)
+    end
+  end
+  
+  def test_create_with_date_time
+    bug = Bug.create(:name => "New Bug!", :priority => 1, :area => "None")
+    assert(bug.date_time)
+    bug.destroy
+  end
+  
+  def test_save_with_date_time
+    bug = Bug.new(:name => "Another new bug!", :priority => 2, :area => "None")
+    bug.save
+    assert(bug.date_time)
+    bug.destroy
+  end
+  
+  def test_destroy
+    bug = Bug.create(:name => "test_destroy", :priority => 1, :area => "None")
+    id = bug.id
+    bug.destroy
+    assert_raise(ActiveRecord::RecordNotFound) { Bug.find(id) }
+  end
+  
+end

data/tests/tc_bug_description.rb

@@ -0,0 +1,32 @@
+require "test/unit"
+
+require File.dirname(__FILE__) + "/../lib/bug_description.rb"
+
+class TestBugDescription < Test::Unit::TestCase
+  def setup
+    Database::connect_to_database(".tracker_db")
+    @bug_names = ["First", "Second", "Third", "Fourth"]
+    @bug_ids = [1, 2, 3, 4]
+    @bug_priorities = [1, 2, 3, 4]
+    @bug_areas = ["One", "Two", "Three", "Four"]
+    @bug_status = [true, true, false, false]
+    @descriptions = ["First description", "Second description", "Third description"]
+  end
+  
+  def teardown
+    
+  end
+  
+  def test_create_with_date_time
+    description = BugDescription.create(:description => "A new description for the first bug.", :bug_id => 1)
+    assert(description.date_time)
+    description.destroy
+  end  
+  
+  def test_save_with_date_time
+    description = BugDescription.new(:description => "A new description for the second bug.", :bug_id => 2)
+    description.save
+    assert(description.date_time)
+    description.destroy
+  end
+end

data/tests/tc_interface.rb

@@ -0,0 +1,9 @@
+require "test/unit"
+
+require File.dirname(__FILE__) + "/../lib/interface.rb"
+
+class TestInterface < Test::Unit::TestCase
+  def test_truth
+    assert(true, "Test truth.")
+  end
+end

data/tests/ts_tracker.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+# Adds current directory - test - and the lib directory to current PATH
+$:.unshift File.join(File.dirname(__FILE__))
+
+# require needed library files
+require 'test/unit'
+require File.dirname(__FILE__) + "/../lib/database.rb"
+
+# Run all tests
+test_cases = `ls #{File.dirname(__FILE__)}`.split("\n").select{ |f| f =~ /tc.*\.rb/ }.each do |file|
+  require File.join(File.dirname(__FILE__), file)
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: Tracker
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-08-23 00:00:00 -07:00
+summary: Command-line bug tracking database application.
+require_paths: 
+- lib
+email: bienhd@gmail.com
+homepage: http://ieng6.ucsd.edu/~hbien/tracker
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: trac
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Hugh Bien
+files: 
+- bin/fixture.rb
+- bin/package
+- bin/trac
+- tests/fixtures.yml
+- tests/tc_action.rb
+- tests/tc_bug.rb
+- tests/tc_bug_description.rb
+- tests/tc_integration.rb
+- tests/tc_interface.rb
+- tests/ts_tracker.rb
+- lib/action.rb
+- lib/bug.rb
+- lib/bug_description.rb
+- lib/database.rb
+- lib/helper.rb
+- lib/interface.rb
+- lib/prompter.rb
+- db/migrate
+- README
+- MIT-LICENSE
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+executables: 
+- trac
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: