ptf 0.1.0 → 0.2.0

data/lib/ptf/commands/task.rb

@@ -7,58 +7,54 @@ module Ptf
       class << self
 
         def show(id)
-          if !Ptf::Utilities::FileSystem.id_exist?(id.to_i)
-            puts "Task #{id} does not exist."
-            return
+          if !Ptf::FileSystem.id_exist?(id.to_i)
+            return "Task #{id} does not exist."
           end
 
-          metadata_file = Ptf::Utilities::FileSystem.find_file id.to_i
+          metadata_file = Ptf::FileSystem.find_file id.to_i
 
           if metadata_file.nil?
-            puts "Task #{id} has been closed. Reopen it with ptf task reopen ###."
-            return
+            return "Task #{id} has been closed. Reopen it with ptf task reopen ###."
           end
 
-          info = Ptf::Data::MetadataFile.new(metadata_file)
+          info = Ptf::MetadataFile.create_from_file(metadata_file)
 
-          data_file = File.join(Ptf::Utilities::FileSystem.data_dir, info.hash)
-          puts `cat #{data_file}`
+          data_file = File.join(Ptf::FileSystem.data_dir, info.hash)
+          return File.read data_file
         end
 
         def close(id)
-          if !Ptf::Utilities::FileSystem.id_exist?(id.to_i)
-            puts "Task #{id} does not exist."
-            return
+          if !Ptf::FileSystem.id_exist?(id.to_i)
+            return "Task #{id} does not exist."
           end
 
-          metadata_file = Ptf::Utilities::FileSystem.find_file id.to_i
+          metadata_file = Ptf::FileSystem.find_file id.to_i
 
           if metadata_file.nil?
-            puts "Task #{id} has been closed. Reopen it with ptf task reopen ###."
-            return
+            return "Task #{id} has been closed. Reopen it with ptf task reopen ###."
           end
 
-          info = Ptf::Data::MetadataFile.create_from_file(metadata_file)
+          info = Ptf::MetadataFile.create_from_file(metadata_file)
 
           info.complete_now
+          return "Task #{info.id} is closed."
         end
 
         def reopen(id)
-          if !Ptf::Utilities::FileSystem.id_exist?(id.to_i)
-            puts "Task #{id} does not exist."
-            return
+          if !Ptf::FileSystem.id_exist?(id.to_i)
+            return "Task #{id} does not exist."
           end
 
-          metadata_file = Ptf::Utilities::FileSystem.find_file id.to_i, false
+          metadata_file = Ptf::FileSystem.find_file id.to_i, false
 
           if metadata_file.nil?
-            puts "Task #{id} is already open. Close it with ptf task close ###."
-            return
+            return "Task #{id} is already open. Close it with ptf task close ###."
           end
 
-          info = Ptf::Data::MetadataFile.create_from_file(metadata_file)
+          info = Ptf::MetadataFile.create_from_file(metadata_file)
 
           info.reopen
+          return "Task #{info.id} is reopened."
         end
 
       end

data/lib/ptf/commands/task/create.rb

@@ -11,7 +11,7 @@ module Ptf
           end
 
           def new_id_number
-            id_file_path = Ptf::Utilities::FileSystem.id_counter_file
+            id_file_path = Ptf::FileSystem.id_counter_file
             next_id = File.read(id_file_path).to_i
 
             id_file = File.new(id_file_path, "w")
@@ -29,38 +29,38 @@ module Ptf
 
             # Select a group for the task
             if group.nil?
-              group = Ptf::Data::Group.default_group
+              group = Ptf::Group.default_group
             else
-              if Ptf::Data::Group.group_exist? group
-                group = Ptf::Data::Group.get_group group
+              if Ptf::Group.group_exist? group
+                group = Ptf::Group.get_group group
               else
-                puts "Group #{p} does not exist. Create it with ptf group add GROUP ABBREVIATION"
-                return
+                return "Group #{p} does not exist. Create it with ptf group add GROUP ABBREVIATION"
               end
             end
 
             # Verify the due date
             if !due_date.nil?
-              due_date = Ptf::Utilities::Date.create_datetime_from_str(due_date)
+              due_date = Ptf::Date.create_datetime_from_str(due_date)
               if due_date.nil?
-                puts "Improperly formatted due date '#{d}' given."
-                return
+                return "Improperly formatted due date '#{d}' given."
               end
             end
 
             id = new_id_number
 
-            info_file = Ptf::Data::MetadataFile.create_from_input(title, group, due_date, estimate, id)
+            info_file = Ptf::MetadataFile.create_from_input(title, group, due_date, estimate, id)
 
             task_info_hash = generate_hash info_file.file_string
 
             # Append hash to the file
             info_file.add_content(:hash, task_info_hash)
 
-            data_file = Ptf::Data::DataFile.new(info_file)
+            data_file = Ptf::DataFile.new(info_file)
 
             info_file.write_to_file
             data_file.write_to_file
+
+            return "Task #{info_file.id} created successfully."
           end
 
         end

data/lib/ptf/commands/task/edit.rb

@@ -4,47 +4,131 @@ module Ptf
       module Edit
         class << self
 
-          def verify_file(file)
-            puts "File verification not implemented"
-            true
+          def verify_file(file, metadata)
+            title_line, due_date_line, estimate_line = File.foreach(file).first(3)
+
+            did_succeed, updated_metadata = verify_title_line title_line, metadata
+            return false unless did_succeed
+
+            did_succeed, updated_metadata = verify_due due_date_line, updated_metadata
+            return false unless did_succeed
+
+            did_succeed, updated_metadata = verify_estimate estimate_line, updated_metadata
+            return false unless did_succeed
+
+            updated_metadata.write_to_file
+            did_succeed
+          end
+
+          def verify_title_line(line, metadata)
+            title_line_regex = /^#([A-Z]+)--(\d+)\s([ a-zA-Z0-9]+)$/
+
+            _, group, id, title = title_line_regex.match(line).to_a
+
+            is_title_valid, updated_metadata = verify_title title, metadata
+            [(verify_group group, metadata) && (verify_id id, metadata) && is_title_valid, updated_metadata]
+          end
+
+          def verify_group(str, metadata)
+            return false unless !str.nil? && str.is_a?(String)
+
+            Ptf::Group.group_exist?(str) && metadata.group.abbreviation == str
+          end
+
+          def verify_id(str, metadata)
+            return false unless !str.nil? && str.is_a?(String)
+
+            str.to_i == metadata.id
+          end
+
+          def verify_title(str, metadata)
+            return false unless !str.nil? && str.is_a?(String)
+
+            if str != metadata.title
+              metadata.set_title str
+            end
+
+            [true, metadata]
+          end
+
+          def verify_due(line, metadata)
+            due_line_regex = /^#Due: ?(\d\d\d\d[01]\d[0-3]\d[0-2]\d[0-5]\d[0-5]\d)?$/
+
+            base, date = due_line_regex.match(line).to_a
+
+            if !base.nil? && date.nil?
+              metadata.set_due_date nil
+              return [true, metadata]
+            end
+
+            begin
+              datetime = Ptf::Date.str_to_datetime date
+            rescue
+              return [false, metadata]
+            end
+
+            metadata.set_due_date datetime
+            [!datetime.nil?, metadata]
+          end
+
+          def verify_estimate(line, metadata)
+            estimate_line_regex = /^#Estimate: ?(\d+)?$/
+
+            base, estimate = estimate_line_regex.match(line).to_a
+
+            if !base.nil? && estimate.nil?
+              metadata.set_estimate nil
+              return [true, metadata]
+            elsif base.nil?
+              return [false, metadata]
+            end
+
+            estimate = estimate.to_i
+            if estimate != 0
+              metadata.set_estimate estimate
+              return [true, metadata]
+            else
+              return [false, metadata]
+            end
           end
 
           def edit(id)
-            unless Ptf::Utilities::FileSystem.id_exist? (id)
-              puts "The task #{id} does not exist"
-              return
+            unless Ptf::FileSystem.id_exist? (id)
+              return "The task #{id} does not exist"
             end
 
-            metadata_file = Ptf::Utilities::FileSystem.find_file id
+            metadata_file = Ptf::FileSystem.find_file id
 
             if metadata_file.nil?
-              puts "The task #{id} has been closed. Reopen it with ptf task reopen ###."
-              return
+              return "The task #{id} has been closed. Reopen it with ptf task reopen ###."
             end
 
             # Get hash from file
-            data_file_name = Ptf::Data::MetadataFile.create_from_file(metadata_file).hash
-            data_file = File.join(Ptf::Utilities::FileSystem.data_dir, data_file_name)
+            metadata = Ptf::MetadataFile.create_from_file(metadata_file)
+            data_file_name = metadata.hash
+            data_file = File.join(Ptf::FileSystem.data_dir, data_file_name)
 
             # Create a copy in tmp foldere
-            tmp_file_path = File.join(Ptf::Utilities::FileSystem.tmp_dir, data_file_name)
+            tmp_file_path = File.join(Ptf::FileSystem.tmp_dir, data_file_name)
             FileUtils.copy data_file, tmp_file_path
             edit_succeeded = system("vim #{data_file}")
 
             if !edit_succeeded
               # Move tmp file back, then remove it
-              puts "Vim edit failed. Aborting changes."
-              return
+
+              FileUtils.copy tmp_file_path, data_file
+              FileUtils.remove_file tmp_file_path
+              return "Vim edit failed. Aborting changes."
             end
 
-            if verify_file(data_file)
-              puts "Edit successful!"
+            if verify_file(data_file, metadata)
+              FileUtils.remove_file tmp_file_path
+              return "Edit successful!"
             else
-              puts "File verification failed. Aborting changes."
+              FileUtils.copy tmp_file_path, data_file
+              FileUtils.remove_file tmp_file_path
+              return "File verification failed. Aborting changes."
             end
-
-            # remove tmp file
-            FileUtils.remove_file tmp_file_path
           end
 
         end

data/lib/ptf/data_file.rb

@@ -0,0 +1,40 @@
+module Ptf
+  class DataFile
+
+    DIR_PATH = Ptf::FileSystem.data_dir
+
+    # Initialize a new DataFile.
+    #
+    # @param metadata_file [Ptf::MetadataFile] the associated metadata file.
+    #
+    # @raise [ArgumntError] if a MetadataFile is not given.
+    def initialize(metadata_file)
+      raise ArgumentError, "Metadata file not given." unless metadata_file.is_a? Ptf::MetadataFile
+
+      @metadata_file = metadata_file
+    end
+
+    # Returns the full path to the data file.
+    #
+    # @return [String] the full path to the data file.
+    def data_file_path
+      File.join(DIR_PATH, @metadata_file.hash)
+    end
+
+    # Returns the header string for the file.
+    #
+    # @return [String] the header string for the data file.
+    def header_string
+      "##{@metadata_file.group.abbreviation}--#{@metadata_file.id} #{@metadata_file.title}\n#Due: #{@metadata_file.due_date_str}\n#Estimate: #{@metadata_file.estimate}\n\n\n"
+    end
+
+    # Write the header string to the data file. Overwrites any data file for the same task.
+    def write_to_file
+      File.open(data_file_path, "w") do |f|
+        f.write header_string
+      end
+    end
+
+  end
+end
+

data/lib/ptf/date.rb

@@ -0,0 +1,61 @@
+module Ptf
+  module Date
+    class << self
+
+      def datetime_to_str(datetime)
+        raise ArgumentError, "DateTime expected. Received #{datetime.class} instead." unless datetime.is_a? DateTime
+
+        datetime.strftime('%Y%m%d%H%M%S')
+      end
+
+      def create_datetime_from_str(str)
+
+        begin
+          dt = str_to_datetime(str)
+          return dt
+        rescue
+        end
+
+        time_regex = /([0-2]?\d):([0-5]\d):?([0-5]\d)?/
+        # Check if given time 12:21(:21)
+        match = time_regex.match(str).to_a
+
+        if !match.nil? && (match.length == 3 || match.length == 4)
+          now = DateTime.now
+          return DateTime.new(now.year, now.month, now.day, match[1].to_i, match[2].to_i, 0, now.zone)
+        end
+
+        # Check if given date 12/27(/[15|2015])
+        date_regex = /^([01]?\d)\/([0-3]?\d)\/?(\d\d\d\d|\d\d)?$/
+        match = date_regex.match(str)
+
+        if !match.nil? && (match.length == 3 || match.length == 4)
+          now = DateTime.now
+
+          if !match[3].nil? && match[3].length == 2
+            year = 2000 + match[3].to_i
+          elsif !match[3].nil?
+            year = match[3].to_i
+          end
+
+          return DateTime.new((match[3].nil? ? now.year : year), match[1].to_i, match[2].to_i, 12, 0, 0, now.zone)
+        end
+
+        nil
+      end
+
+      def str_to_datetime(str)
+        date_regex = /^(\d\d\d\d)([01]\d)([0-3]\d)([0-2]\d)([0-5]\d)([0-5]\d)?$/
+
+        regex_match = date_regex.match(str)
+
+        raise ArgumentError, "Improperly formatted datetime string, #{str}." unless regex_match.to_a.length == 7
+
+        _, year, month, day, hour, minute, second = regex_match.to_a
+
+        DateTime.new(year.to_i, month.to_i, day.to_i, hour.to_i, minute.to_i, second.to_i)
+      end
+
+    end
+  end
+end

data/lib/ptf/file_system.rb

@@ -0,0 +1,81 @@
+module Ptf
+  module FileSystem
+    class << self
+
+      def file_exist?(filepath)
+        File.file?(filepath)
+      end
+
+      def config
+        @config = Ptf::Config.get_config if @config.nil?
+
+        @config
+      end
+
+      def file_permission
+        @config[:file_permission]
+      end
+
+      def base_dir
+        config[:base_dir]
+      end
+
+      def id_counter_file
+        File.join(base_dir, config[:task_counter_file])
+      end
+
+      def id_counter_starting_content
+        config[:id_counter_start]
+      end
+
+      def group_list_file
+        File.join(base_dir, config[:group_list_file])
+      end
+
+      def metadata_dir
+        File.join(base_dir, config[:task_metadata_dir])
+      end
+
+      def metadata_open_dir
+        File.join(metadata_dir, config[:in_progress_dir])
+      end
+
+      def metadata_closed_dir
+        File.join(metadata_dir, config[:completed_dir])
+      end
+
+      def data_dir
+        File.join(base_dir, config[:task_data_dir])
+      end
+
+      def tmp_dir
+        File.join(base_dir, config[:tmp_dir])
+      end
+
+      def id_exist?(id)
+        next_id = File.read(id_counter_file).to_i
+
+        (id < next_id && id > 0)
+      end
+
+      def find_file(id, open = true)
+        raise ArgumentError, "No task with id #{id} exists." unless id_exist?(id)
+
+        search_dir = (open ? metadata_open_dir : metadata_closed_dir)
+        groups = Ptf::Group.all_groups
+
+        groups.each do |g|
+          dir = File.join(search_dir, g.name)
+          possible_id_file = File.join(dir, id.to_s)
+
+          if file_exist?(possible_id_file)
+            return possible_id_file
+          end
+        end
+
+        nil
+      end
+
+    end
+  end
+end