ptf 0.1.0

data/lib/ptf/commands/task.rb

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

data/lib/ptf/commands.rb

@@ -0,0 +1,13 @@
+require 'ptf/commands/init'
+require 'ptf/commands/list'
+require 'ptf/commands/task'
+require 'ptf/commands/group'
+
+module Ptf
+  module Commands
+    class << self
+
+    end
+  end
+end
+

data/lib/ptf/config.rb

@@ -0,0 +1,42 @@
+require 'yaml'
+
+module Ptf
+  module Config
+    YAML_LOCATION = File.join(Dir.home, ".ptfconfig")
+
+    EDITABLE = {
+      :default_group => "unassigned:NONE",
+      :base_dir => File.join(Dir.home, ".ptf")
+    }
+
+    STATIC = {
+      :file_permission => 0700,
+      :id_counter_start => "1",
+      :task_metadata_dir => "info",
+      :task_data_dir => "data",
+      :in_progress_dir => "open",
+      :completed_dir => "closed",
+      :tmp_dir => "tmp",
+      :task_counter_file => "id_counter",
+      :group_list_file => "group_list"
+    }
+
+    def self.get_config
+      yaml_settings = {}
+
+      yaml_settings = YAML.load(File.read(YAML_LOCATION)) if File.exist?(YAML_LOCATION)
+
+      EDITABLE.merge(yaml_settings).merge(STATIC)
+    end
+
+    def self.write_config(config)
+      new_config = EDITABLE.merge config.select { |k| EDITABLE.keys.include? k }
+
+      yaml_file = File.new(YAML_LOCATION, "w")
+      yaml_file.puts new_config.to_yaml
+      yaml_file.close
+    end
+
+  end
+end
+

data/lib/ptf/data/data_file.rb

@@ -0,0 +1,42 @@
+module Ptf
+  module Data
+    class DataFile
+
+      DIR_PATH = Ptf::Utilities::FileSystem.data_dir
+
+      # Initialize a new DataFile.
+      #
+      # @param metadata_file [Ptf::Data::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::Data::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
+end
+

data/lib/ptf/data/group.rb

@@ -0,0 +1,107 @@
+module Ptf
+  module Data
+    class Group
+
+      def initialize(name, abbrev)
+        @name = name
+        @abbreviation = abbrev
+      end
+
+      def name
+        @name
+      end
+
+      def abbreviation
+        @abbreviation
+      end
+
+      def to_s
+        "#{name}:#{abbreviation}"
+      end
+
+      class << self
+        def from_name(group_name)
+          group_file = Ptf::Utilities::FileSystem.group_list_file
+          File.open(group_file, "r") do |f|
+            f.each_line do |l|
+              name, abbrev = l.gsub(/\s+/, "").split(":")
+
+              if group_name == name
+                return Group.new(name, abbrev)
+              end
+
+            end
+          end
+
+          nil
+        end
+
+        def from_abbrev(group_abbrev)
+          group_file = Ptf::Utilities::FileSystem.group_list_file
+          File.open(group_file, "r") do |f|
+            f.each_line do |l|
+              name, abbrev = l.gsub(/\s+/, "").split(":")
+
+              if group_abbrev == abbrev
+                return Group.new(name, abbrev)
+              end
+
+            end
+          end
+
+          nil
+        end
+
+        def get_group(group)
+          if(group.length <= 4 && group == group.upcase)
+            from_abbrev(group)
+          else
+            from_name(group)
+          end
+        end
+
+        def group_exist?(g)
+          group_file = Ptf::Utilities::FileSystem.group_list_file
+
+          File.open(group_file, "r") do |f|
+            f.each_line do |l|
+              name, abbrev = l.gsub(/\s+/, "").split(":")
+
+              if name == g || abbrev == g
+                return true
+              end
+
+            end
+          end
+
+          false
+        end
+
+        def all_groups
+          group_arr = []
+
+          File.open(Ptf::Utilities::FileSystem.group_list_file, "r") do |f|
+            f.each_line do |l|
+              name, abbrev = l.gsub(/\s+/, "").split(":")
+
+              group_arr.push (Ptf::Data::Group.new(name, abbrev))
+            end
+          end
+
+          group_arr
+        end
+
+        def default_group
+          config = Ptf::Config.get_config
+          default_group = config[:default_group]
+
+          name, abbrev = default_group.gsub(/\s+/, "").split(":")
+          Ptf::Data::Group.new(name, abbrev)
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/ptf/data/metadata_file.rb

@@ -0,0 +1,237 @@
+module Ptf
+  module Data
+    # Represents a single Metadata file.
+    #
+    # @author Austin Blatt
+    # @since 0.1.0
+    class MetadataFile
+
+      # Create a MetadataFile object from the given input.
+      #
+      # @param title [String] the task's title.
+      # @param group [Ptf::Data::Group] the Group the task is associated with.
+      # @param due_date [DateTime, nil] the due date given for the task.
+      # @param estimate [Numeric, nil] the estimated time to complete the task.
+      # @param id [Integer] the unique ID number for this task.
+      #
+      # @return [Ptf::Data::MetadataFile] the metadata file for the task.
+      def self.create_from_input(title, group, due_date, estimate, id)
+        data = {
+          :title => title,
+          :group => group,
+          :due_date => due_date,
+          :estimate => estimate,
+          :id => id,
+          :created_at => DateTime.now,
+          :completed_at => nil
+        }
+
+        # Get the filepath for the infofile
+        open_dir = Ptf::Utilities::FileSystem.metadata_open_dir
+        group_dir = File.join(open_dir, group.name)
+        filepath = File.join(group_dir, id.to_s)
+
+        self.new(filepath, data)
+      end
+
+      # Create a MetadataFile object from the given filepath.
+      #
+      # @param filepath [String] the full file path to the metadata file.
+      #
+      # @raise [ArgumentError] if the given filepath does not exist.
+      # @raise [ArgumentError] if the given file is not a metadata file.
+      #
+      # @return [Ptf::Data::MetadataFile] the object representation of the metadata file.
+      def self.create_from_file(filepath)
+        raise ArgumentError, "File #{filepath} does not exist." unless Ptf::Utilities::FileSystem.file_exist?(filepath)
+
+        data = {}
+        # parse file
+        File.open(filepath, "r") do |f|
+          f.each_line do |l|
+            key, val = l.gsub(/\s+/, "").split(":")
+
+            if key.nil? || !(key.is_a? String)
+              raise ArgumentError, "Error parsing file."
+            end
+
+            # Convert values to appropriate types
+            case key
+            when "group"
+              val = Ptf::Data::Group.from_name(val)
+            when "due_date", "created_at", "completed_at"
+              val = (val.nil? ? val : Ptf::Utilities::Date.str_to_datetime(val))
+            when "id"
+              val = val.to_i
+            when "estimate"
+              val = (val.nil? ? nil : val.to_i)
+            end
+
+            data[key.to_sym] = val
+          end
+        end
+
+        return self.new(filepath, data)
+      end
+
+      # Initialize a new metadata file.
+      #
+      # @param filepath [String] the full path to the file.
+      # @param data [Hash] the data in the file.
+      # @option data [String] :title the task's title.
+      # @option data [Ptf::Data::Group] :group the Group the task is associated with.
+      # @option data [DateTime, nil] :due_date the due date given for the task.
+      # @option data [Integer, nil] :estimate the estimated time to complete the task.
+      # @option data [Integer] :id the unique ID number for this task.
+      # @option data [DateTime] :created_at the time the task was created.
+      # @option data [DateTime, nil] :completed_at the time the task was completed (nil if it has not been completed).
+      # @option data [String] :hash the file hash (the filepath of the data file).
+      def initialize(filepath, data)
+        @filepath = filepath
+        @data = data
+      end
+
+      # Add content to the metadata file.
+      #
+      # @param key [Symbol] the key for the new content.
+      # @param val [Object] the value for the new content.
+      #
+      # @raise [ArgumentError] if the key is not a symbol.
+      def add_content(key, val)
+        raise ArgumentError, "The key #{key} is not a symbol." unless key.is_a? Symbol
+
+        @data[key] = val
+      end
+
+      # Returns the title of the task.
+      #
+      # @return [String] the title of the task.
+      def title
+        @data[:title]
+      end
+
+      # Returns the group the task is associated with.
+      #
+      # @return [Ptf::Data::Group] the group the task is associated with.
+      def group
+        @data[:group]
+      end
+
+      # Returns the due date of the task.
+      #
+      # @return [DateTime, nil] the due date of the task or nil if no due date exists.
+      def due_date
+        @data[:due_date]
+      end
+
+      # Returns the due date of the task as a String.
+      #
+      # @return [String] the due date of the task as a string.
+      def due_date_str
+        return "" if due_date.nil?
+
+        Ptf::Utilities::Date.datetime_to_str(due_date)
+      end
+
+      # Returns the due date of the task for the ptf list command.
+      #
+      # @return [String] the due date in the form 'Mon Dec 19 - 11AM -' or 'Mon Dec  9 -  2PM -'.
+      def due_date_list_format
+        return "" if due_date.nil?
+
+        due_date.strftime("%a %b %_d - %l%p -")
+      end
+
+      # Returns the estimated time to complete the task.
+      #
+      # @return [Numeric] the estimated time to compelte the task.
+      def estimate
+        @data[:estimate]
+      end
+
+      # Returns the date and time that the task was created at.
+      #
+      # @return [DateTime] the date and time that the task was created at.
+      def created_at
+        @data[:created_at]
+      end
+
+      # Returns the date and time that the task was created at as a String.
+      #
+      # @return [String] the date and time represented as a string.
+      def created_at_str
+        Ptf::Utilities::Date.datetime_to_str(@data[:created_at])
+      end
+
+      # Return the id of the task.
+      #
+      # @return [Integer] the ID number of the task.
+      def id
+        @data[:id]
+      end
+
+      # Return the hash of the task.
+      #
+      # @return [String] the hash of the metadata file (the name of the data file).
+      def hash
+        @data[:hash]
+      end
+
+      # Completes the task.
+      #
+      # Fills in the completed_at field with the current DateTime.
+      # Removes the metadata file from the in progress directory and writes it to the completed directory.
+      def complete_now
+        @data[:completed_at] = DateTime.now
+
+        `rm #{@filepath}`
+        @filepath = File.join(File.join(Ptf::Utilities::FileSystem.metadata_closed_dir, group.name), id.to_s)
+
+        write_to_file
+      end
+
+      def reopen
+        `rm #{@filepath}`
+        @filepath = File.join(File.join(Ptf::Utilities::FileSystem.metadata_open_dir, group.name), id.to_s)
+
+        write_to_file
+      end
+
+      def key_val_to_str(key, val)
+        str_val = val
+        case key
+        when :group
+          str_val = val.name
+        when :due_date, :created_at, :completed_at
+          str_val = (val.nil? ? "" : Ptf::Utilities::Date.datetime_to_str(val))
+        end
+
+        "#{key}:#{str_val}"
+      end
+        
+      # Returns the data in the file as a String.
+      #
+      # @return [String] the entire Metadata file as a String.
+      def file_string
+        return_str = ""
+        @data.each do |key, val|
+          return_str += "#{key_val_to_str(key, val)}\n"
+        end
+
+        return_str
+      end
+
+      # Writes the metadata file. Overwrites any previous metadata file for the same task.
+      def write_to_file
+        file = File.new(@filepath, "w")
+
+        @data.each do |key, val|
+          file.puts "#{key_val_to_str(key, val)}"
+        end
+        file.close
+      end
+
+    end
+  end
+end
+

data/lib/ptf/data.rb

@@ -0,0 +1,9 @@
+require 'ptf/data/group'
+require 'ptf/data/metadata_file'
+require 'ptf/data/data_file'
+
+module Ptf
+  module Data
+  end
+end
+

data/lib/ptf/utilities/date.rb

@@ -0,0 +1,63 @@
+module Ptf
+  module Utilities
+    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
+end

data/lib/ptf/utilities/file_system.rb

@@ -0,0 +1,83 @@
+module Ptf
+  module Utilities
+    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::Data::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
+end

data/lib/ptf/utilities.rb

@@ -0,0 +1,28 @@
+require 'ptf/utilities/date'
+require 'ptf/utilities/file_system'
+
+module Ptf
+  module Utilities
+    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 str_to_datetime(str)
+        date_regex = /^([0-9][0-9][0-9][0-9])([01][0-9])([0-3][0-9])?([0-2][0-9])([0-5][0-9])([0-5][0-9])$/
+
+        regex_match = date_regex.match(str)
+
+        raise ArgumentError, "Improperly formatted datetime string." 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/version.rb

@@ -0,0 +1,3 @@
+module Ptf
+  VERSION = "0.1.0"
+end