ptf 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d061046d970e40aa337b3d7c22d6694c86218ed1
-  data.tar.gz: 2d7f5790adb59b3384be8ee40a8a750a16519202
+  metadata.gz: b064a82fc522d39a16f0e27203cdfdd38a75c6fb
+  data.tar.gz: 162fc849a41882f39ceee43bbae6c35d1e7abbcc
 SHA512:
-  metadata.gz: 2227f3d74a214e752cb2fe504d8a7824a31b949123807c7305127be1f9f172ad2169fc1025cd191d0c05e6a62879f159f591f9f04bef52643b6522403f5398e1
-  data.tar.gz: 5dc3cd5181bedc740c02c8036884b24bd0d936a49c5589426a9e68d8e3ca5298fbc922fd037f6bc7634e5ed7a0a3ea19d17ecca0bc8e4ccd4d71f64b7af01731
+  metadata.gz: f348ea5ab25b189b8ac0f01a29e3a639836d17adc8c555111c3d592b67b1089e287718b771784bd5243d9711986ef94984773e70093118c1f21341a2e1c5c35c
+  data.tar.gz: 88e2b468612959d5e32271ed38bd14e36d22732f7a3b7f423caa8f775c045f32a27a157915f25457274fad59845667dafc46b6af6d0d861572a20ffa7d4f0dd4

data/lib/ptf.rb

@@ -1,8 +1,11 @@
 require 'ptf/version'
 require 'ptf/client'
 require 'ptf/config'
-require 'ptf/utilities'
-require 'ptf/data'
+require 'ptf/date'
+require 'ptf/file_system'
+require 'ptf/data_file'
+require 'ptf/group'
+require 'ptf/metadata_file'
 require 'ptf/commands'
 
 module Ptf

data/lib/ptf/client.rb

@@ -16,7 +16,7 @@ module Ptf
       LONGDESC
       option :f, :type => :boolean
       def init
-        Ptf::Commands::Init.init(options[:f])
+        puts Ptf::Commands::Init.init(options[:f])
       end
 
       desc "task", "Subcommand to manage tasks"
@@ -26,8 +26,10 @@ module Ptf
       subcommand "group", Group
 
       desc "list DELIMIT", "List tasks. Given 'all' or a group name"
+      option :open, :type => :boolean, :aliases => :o
+      option :closed, :type => :boolean, :aliases => :c
       def list(delimiter)
-        Ptf::Commands::List.list(delimiter)
+        puts Ptf::Commands::List.list(delimiter, options[:open], options[:closed])
       end
 
       desc "summary", "Subcommand to manage a summary of all tasks"

data/lib/ptf/client/group.rb

@@ -2,19 +2,14 @@ module Ptf
   module Cli
     class Group < Thor
 
-      desc "group add GROUP ABBREVIATION", "Create a new group"
+      desc "add GROUP ABBREVIATION", "Create a new group"
       def add(group, abbrev)
-        Ptf::Commands::Group::Add.add(group, abbrev)
+        puts Ptf::Commands::Group::Add.add(group, abbrev)
       end
 
-      desc "group remove", "Remove a group"
-      def remove
-        puts "remove group not implemented"
-      end
-
-      desc "group transfer", "Transfer a group to another"
-      def transfer
-        puts "transfer group not implemented"
+      desc "remove GROUP", "Remove a group"
+      def remove(group)
+        puts Ptf::Commands::Group::Remove.remove(group)
       end
 
     end

data/lib/ptf/client/summary.rb

@@ -2,17 +2,17 @@ module Ptf
   module Cli
     class Summary < Thor
 
-      desc "summary create", "Create a summary"
+      desc "create", "Create a summary"
       def create
         puts "summary create not implemented"
       end
 
-      desc "summary edit", "Edit summary"
+      desc "edit", "Edit summary"
       def edit
         puts "summary edit not implemented"
       end
 
-      desc "summary show", "Show summary"
+      desc "show", "Show summary"
       def show
         puts "summary show not implemented"
       end

data/lib/ptf/client/task.rb

@@ -2,33 +2,33 @@ module Ptf
   module Cli
     class Task < Thor
 
-      desc "task create", "Create a new task"
+      desc "create", "Create a new task"
       option :title, :type => :string, :required => true, :aliases => :t
       option :group, :type => :string, :aliases => :g
       option :date, :type => :string, :aliases => :d
       option :estimate, :type => :numeric, :aliases => :e
       def create
-        Ptf::Commands::Task::Create.create(options[:title], options[:group], options[:date], options[:estimate])
+        puts Ptf::Commands::Task::Create.create(options[:title], options[:group], options[:date], options[:estimate])
       end
 
-      desc "task edit ID", "Edit a task"
+      desc "edit ID", "Edit a task"
       def edit(id)
-        Ptf::Commands::Task::Edit.edit(id.to_i)
+        puts Ptf::Commands::Task::Edit.edit(id.to_i)
       end
 
-      desc "task show ID", "Show a task"
+      desc "show ID", "Show a task"
       def show(id)
-        Ptf::Commands::Task.show(id)
+        puts Ptf::Commands::Task.show(id)
       end
 
-      desc "task close ID", "Mark a task a completed"
+      desc "close ID", "Mark a task a completed"
       def close(id)
-        Ptf::Commands::Task.close(id)
+        puts Ptf::Commands::Task.close(id)
       end
 
-      desc "task reopen ID", "Reopen a closed task"
+      desc "reopen ID", "Reopen a closed task"
       def reopen(id)
-        Ptf::Commands::Task.reopen(id)
+        puts Ptf::Commands::Task.reopen(id)
       end
 
     end

data/lib/ptf/commands/group.rb

@@ -1,4 +1,5 @@
 require 'ptf/commands/group/add'
+require 'ptf/commands/group/remove'
 
 module Ptf
   module Commands

data/lib/ptf/commands/group/add.rb

@@ -5,41 +5,36 @@ module Ptf
         class << self
 
           def add(group, abbrev)
-            if Ptf::Data::Group.group_exist?(group)
-              puts "Group already exists using the name #{group}."
-              return
-            elsif Ptf::Data::Group.group_exist?(abbrev)
-              puts "Group already exists using the abbreviation #{abbrev}."
-              return
+            if Ptf::Group.group_exist?(group)
+              return "Group already exists using the name #{group}."
+            elsif Ptf::Group.group_exist?(abbrev)
+              return "Group already exists using the abbreviation #{abbrev}."
             end
 
             if abbrev.length > 4
-              puts "Abbreviation cannot be longer than 4 characters."
-              return
+              return "Abbreviation cannot be longer than 4 characters."
             end
 
             if group != group.downcase
-              puts "Group names must be entirely lowercase."
-              return
+              return "Group names must be entirely lowercase."
             elsif abbrev != abbrev.upcase
-              puts "Group abbreviations must be entirely uppercase."
-              return
+              return "Group abbreviations must be entirely uppercase."
             end
 
-            new_group = Ptf::Data::Group.new(group, abbrev)
+            new_group = Ptf::Group.new(group, abbrev)
 
-            group_file = Ptf::Utilities::FileSystem.group_list_file
+            group_file = Ptf::FileSystem.group_list_file
 
             File.open(group_file, 'a') { |f| f.write("#{new_group.to_s}\n") }
 
-            open_dir = Ptf::Utilities::FileSystem.metadata_open_dir
-            closed_dir = Ptf::Utilities::FileSystem.metadata_closed_dir
+            open_dir = Ptf::FileSystem.metadata_open_dir
+            closed_dir = Ptf::FileSystem.metadata_closed_dir
 
             [open_dir, closed_dir].each do |d|
-              Dir.mkdir(File.join(d, new_group.name), Ptf::Utilities::FileSystem.file_permission)
+              Dir.mkdir(File.join(d, new_group.name), Ptf::FileSystem.file_permission)
             end
 
-            puts "Added group #{new_group.to_s} successfully!"
+            return "Added group #{new_group.to_s} successfully!"
           end
 
         end

data/lib/ptf/commands/group/remove.rb

@@ -0,0 +1,52 @@
+module Ptf
+  module Commands
+    module Group
+      module Remove
+        class << self
+
+          def remove(group)
+            if !Ptf::Group.group_exist?(group)
+              return "Group #{group} does not exist. Add it with ptf group add GROUP ABBREVIATION."
+            end
+
+            group = Ptf::Group.get_group(group)
+
+            if group.is_default?
+              return "#{group.to_s} is the default group. It cannot be removed."
+            end
+
+            # Prompt for user confirmation
+            puts "Are you sure you want to remove #{group.to_s}? This will delete ALL tasks associated with this group."
+            confirm = STDIN.gets.chomp
+
+            if confirm.downcase != "y" && confirm.downcase != "yes"
+              return "Group removal aborted."
+            end
+
+            # Remove from group_list
+            tmp_file = "#{Ptf::FileSystem.group_list_file}.tmp"
+            File.open(Ptf::FileSystem.group_list_file, "r") do |original|
+              File.open(tmp_file, "w") do |tmp|
+                original.each_line do |line|
+                  tmp.write(line) unless line.gsub(/\s+/, "") == group.to_s
+                end
+              end
+            end
+
+            File.rename(tmp_file, Ptf::FileSystem.group_list_file)
+
+            # Remove from info/open/[group]
+            FileUtils.rm_r File.join(Ptf::FileSystem.metadata_open_dir, group.name)
+
+            # Remove from info/closed/[group]
+            FileUtils.rm_r File.join(Ptf::FileSystem.metadata_closed_dir, group.name)
+
+            return "Group removed."
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/ptf/commands/init.rb

@@ -5,57 +5,56 @@ module Ptf
 
         def init(force_override = false)
 
-          default_permissions = Ptf::Utilities::FileSystem.file_permission
-          default_group = Ptf::Data::Group.default_group
-          default_counter = Ptf::Utilities::FileSystem.id_counter_starting_content
+          default_permissions = Ptf::FileSystem.file_permission
+          default_group = Ptf::Group.default_group
+          default_counter = Ptf::FileSystem.id_counter_starting_content
 
-          base_dir = Ptf::Utilities::FileSystem.base_dir
+          base_dir = Ptf::FileSystem.base_dir
 
+          return_prefix = ""
           if Dir.exist? base_dir
             if force_override
-              puts "PTF workspace existed, erasing..."
-              `rm -r #{base_dir}`
+              FileUtils.rm_r base_dir
+              return_prefix = "PTF workspace existed, erasing...\n"
             else
-              puts "A PTF workspace has already been initialized."
-              return
+              return "A PTF workspace has already been initialized."
             end
           end
 
           begin
             Dir.mkdir(base_dir, default_permissions)
 
-            info_dir = Ptf::Utilities::FileSystem.metadata_dir
+            info_dir = Ptf::FileSystem.metadata_dir
             Dir.mkdir(info_dir, default_permissions)
 
-            data_dir = Ptf::Utilities::FileSystem.data_dir
+            data_dir = Ptf::FileSystem.data_dir
             Dir.mkdir(data_dir, default_permissions)
 
-            tmp_dir = Ptf::Utilities::FileSystem.tmp_dir
+            tmp_dir = Ptf::FileSystem.tmp_dir
             Dir.mkdir(tmp_dir, default_permissions)
 
-            open_dir = Ptf::Utilities::FileSystem.metadata_open_dir
+            open_dir = Ptf::FileSystem.metadata_open_dir
             Dir.mkdir(open_dir, default_permissions)
 
-            closed_dir = Ptf::Utilities::FileSystem.metadata_closed_dir
+            closed_dir = Ptf::FileSystem.metadata_closed_dir
             Dir.mkdir(closed_dir, default_permissions)
 
             Dir.mkdir(File.join(open_dir, default_group.name), default_permissions)
             Dir.mkdir(File.join(closed_dir, default_group.name), default_permissions)
 
-            counter_file = File.new(Ptf::Utilities::FileSystem.id_counter_file, "w")
+            counter_file = File.new(Ptf::FileSystem.id_counter_file, "w")
             counter_file.puts default_counter
             counter_file.close
 
-            group_file = File.new(Ptf::Utilities::FileSystem.group_list_file, "w")
+            group_file = File.new(Ptf::FileSystem.group_list_file, "w")
             group_file.puts default_group.to_s
             group_file.close
-          rescue Exception => e
-            puts "Failed to create PTF workspace."
-            `rm -r #{base_dir}`
-            raise e
+          rescue
+            FileUtils.rm_r base_dir
+            return return_prefix + "Failed to create PTF workspace."
           end
 
-          puts "Created PTF workspace at #{base_dir} successfully!"
+          return return_prefix + "Created PTF workspace at #{base_dir} successfully!"
         end
 
       end

data/lib/ptf/commands/list.rb

@@ -3,24 +3,41 @@ module Ptf
     module List
       class << self
 
-        def get_metadata_for_group(group)
-          raise ArgumentError, "Group #{group} does not exist." unless Ptf::Data::Group.group_exist?(group)
+        def get_metadata_for_group(group, flag)
+          raise ArgumentError, "Group #{group} does not exist." unless Ptf::Group.group_exist?(group)
 
-          group_name = Ptf::Data::Group.get_group(group).name
-          open_group_path = File.join(Ptf::Utilities::FileSystem.metadata_open_dir, group_name)
+          group_name = Ptf::Group.get_group(group).name
+          open_group_path = File.join(Ptf::FileSystem.metadata_open_dir, group_name)
           open_group_dir = Dir.new(open_group_path)
-          # closed_group_dir = File.join(Ptf::Utilities::FileSystem.metadata_closed_dir, group)
+          closed_group_path = File.join(Ptf::FileSystem.metadata_closed_dir, group_name)
+          closed_group_dir = Dir.new(closed_group_path)
+
+          open_tasks = []
+          closed_tasks = []
+          if flag == :open || flag == :both
+            open_group_dir.to_a.each do |file|
+              path = File.join(open_group_path, file)
+
+              if File.file? path
+                open_tasks.push Ptf::MetadataFile.create_from_file(path)
+              end
+            end
+          end
 
-          open_tasks = open_group_dir.to_a[2..-1].collect do |file|
-            path = File.join(open_group_path, file)
+          if flag == :closed || flag == :both
+            closed_group_dir.to_a.each do |file|
+              path = File.join(closed_group_path, file)
 
-            Ptf::Data::MetadataFile.create_from_file(path)
+              if File.file? path
+                closed_tasks.push Ptf::MetadataFile.create_from_file(path)
+              end
+            end
           end
 
-          open_tasks
+          [open_tasks, closed_tasks]
         end
 
-        def sort_task_arr(task_arr)
+        def sort_open_task_arr(task_arr)
           sorted_arr = task_arr
 
           sorted_arr.sort! do |a,b|
@@ -38,10 +55,20 @@ module Ptf
           sorted_arr
         end
 
-        def generate_list_display(tasks)
+        def sort_closed_task_arr(task_arr)
+          sorted_arr = task_arr
+
+          sorted_arr.sort! do |a,b|
+            b.completed_at <=> a.completed_at
+          end
+
+          sorted_arr
+        end
+
+        def generate_list_display(open, closed)
           list_display = ""
           first = true, past_due = false, have_due_date = true
-          tasks.each do |t|
+          open.each do |t|
             if have_due_date && t.due_date.nil?
               have_due_date = false
               list_display += "\n" unless first
@@ -65,23 +92,51 @@ module Ptf
             list_display += "#{t.due_date_list_format} #{t.title} (#{t.group.abbreviation} #{t.id})\n"
           end
 
+          show_closed_banner = true
+          closed.each do |t|
+            if show_closed_banner
+              list_display += "\n" unless list_display == ""
+              list_display += "=========== Closed ===========\n\n"
+              show_closed_banner = false
+            end
+
+            list_display += "#{t.completed_at_list_format} #{t.title} (#{t.group.abbreviation} #{t.id})\n"
+          end
+
           list_display
         end
 
-        def list(delimiter)
-          if delimiter.downcase == "all"
-            puts "List all not yet implemented"
+        def list(delimiter, open, closed)
+          if open && closed
+            flag = :both
+          elsif closed
+            flag = :closed
           else
-            if !Ptf::Data::Group.group_exist?(delimiter)
-              puts "Group #{delimiter} does not exist."
-              return
+            flag = :open
+          end
+
+          if delimiter.downcase == "all"
+            all_groups = Ptf::Group.all_groups
+
+            open_tasks = []
+            closed_tasks = []
+            all_groups.each do |g|
+              open, closed = get_metadata_for_group(g.name, flag)
+              open_tasks.concat open
+              closed_tasks.concat closed
             end
 
-            tasks = get_metadata_for_group(delimiter)
-            tasks = sort_task_arr(tasks)
+          else
+            if !Ptf::Group.group_exist?(delimiter)
+              return "Group #{delimiter} does not exist."
+            end
 
-            puts generate_list_display(tasks)
+            open_tasks, closed_tasks = get_metadata_for_group(delimiter, flag)
           end
+
+          open_tasks = sort_open_task_arr(open_tasks)
+          closed_tasks = sort_closed_task_arr(closed_tasks)
+          return generate_list_display(open_tasks, closed_tasks)
         end
 
       end