Tracker 0.1.2 → 1.0.0

data/lib/bug_description.rb

@@ -1,15 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,16 +0,0 @@
-# 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

@@ -1,175 +0,0 @@
-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"
-require 'yaml'
-
-# 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 = "trac"
-    config = {}
-    if File.exist?(ENV['HOME'] + "/.tracrc")
-      config = open(ENV['HOME'] + '/.tracrc') { |f| YAML.load(f) }
-    end
-    @all_options = ["name", "priority", "area", "description"].delete_if { |i| config.has_key? i }
-  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
-      if !hash.has_key?(:name)
-        print_usage
-      elsif
-        method_name = "help_" + hash[:name]
-        if Action.respond_to?(method_name)
-          Action.send(method_name) 
-        else
-          puts "The command #{hash[:name]} doesn't exist - try 'trac help' for a list of commands."
-        end
-      end
-    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" unless bug.priority.nil?
-    working_string << "Area:         #{bug.area}\n" unless bug.area.nil?
-    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   [command]"
-    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

@@ -1,66 +0,0 @@
-# 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/test/test_action.rb

@@ -1,147 +0,0 @@
-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 TestAction < 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