now-task-manager 0.1.0

data/lib/pomodoro/formats/today/task.rb

@@ -0,0 +1,92 @@
+require 'pomodoro/exts/hour'
+require 'pomodoro/formats/today'
+require 'pomodoro/formats/today/task/statuses'
+require 'pomodoro/formats/today/task/dynamic_additions'
+require 'pomodoro/formats/today/task/metadata'
+
+module Pomodoro::Formats::Today
+  class Task
+    STATUS_MAPPING ||= {
+      not_done: ['-'],
+      done: ['✓', '✔', '☑'],
+      failed:   ['✕', '☓', '✖', '✗', '✘', '☒'],
+      # wip:      ['☐', '⛶', '⚬']
+    }
+
+    STATUS_LIST ||= STATUS_MAPPING.keys
+
+    include TaskStatuses
+    include DynamicAdditions
+
+    attr_reader :status, :body, :start_time, :end_time, :fixed_start_time, :duration, :tags, :lines
+    def initialize(status:, body:, start_time: nil, end_time: nil, fixed_start_time: nil, duration: nil, tags: [], lines: [])
+      @status, @body, @tags, @duration = status, body, tags, duration
+      @start_time, @end_time, @fixed_start_time = start_time, end_time, fixed_start_time
+      validate_data_integrity
+    end
+
+    def remaining_duration(current_time_frame)
+      @start_time || raise("The task #{self.inspect} hasn't been started yet.")
+
+      closing_time = @start_time + duration
+      interval_end_time = current_time_frame.interval[1]
+    end
+
+    def to_s
+      Formatter.format(self)
+    end
+
+    private
+    def format_duration
+      if @start_time && @end_time
+        [@start_time, @end_time].join('-')
+      elsif @start_time
+        "started at #{@start_time}"
+      elsif @end_time
+        raise 'nonsense'
+      else # nil
+      end
+    end
+
+    def validate_nil_or_instance_of(expected_class, instance, var_name)
+      instance && (instance.is_a?(expected_class) ||
+        raise(ArgumentError.new("#{var_name} has to be an instance of #{expected_class}.")))
+    end
+
+    def validate_data_integrity
+      validate_nil_or_instance_of(Hour, @start_time,       :start_time)
+      validate_nil_or_instance_of(Hour, @end_time,         :end_time)
+      validate_nil_or_instance_of(Hour, @fixed_start_time, :fixed_start_time)
+
+      if @start_time.nil? && @end_time
+        raise ArgumentError.new("Setting end_time without start_time is invalid.")
+      end
+
+      if @start_time && @end_time && @start_time >= @end_time
+        raise ArgumentError.new("start_time has to be smaller than end_time.")
+      end
+
+      if @duration && ! (@duration.respond_to?(:integer?) && @duration.integer?)
+        raise ArgumentError.new("Duration has to be an integer.")
+      end
+
+      if @duration && ! (5..90).include?(@duration)
+        raise ArgumentError.new("Duration has between 5 and 90 minutes.")
+      end
+
+      unless STATUS_LIST.include?(@status)
+        raise ArgumentError.new("Status has to be one of #{STATUS_SYMBOLS.keys.inspect}.")
+      end
+
+      # Unstarted or in progress.
+      if @status == :not_done && @end_time
+        raise ArgumentError.new("A task with status :not_done cannot have an end_time!")
+      end
+
+      if [:done, :failed].include?(@status) && ! (
+        (@start_time && @end_time) || (! @start_time && ! @end_time))
+        raise ArgumentError.new("Task has ended. It can either have start_time and end_time or neither, not only one of them.")
+      end
+    end
+  end
+end

data/lib/pomodoro/formats/today/task/dynamic_additions.rb

@@ -0,0 +1,5 @@
+module Pomodoro::Formats::Today
+  module DynamicAdditions
+    attr_accessor :command
+  end
+end

data/lib/pomodoro/formats/today/task/metadata.rb

@@ -0,0 +1,37 @@
+require 'pomodoro/formats/today'
+
+module Pomodoro::Formats::Today
+  # - A task. #cool
+  #   Log about how is it going with the task.
+  #
+  #   One more paragraph.
+  #
+  #   ✔ Subtask 1.
+  #   ✘ Subtask 2.
+  #   - Subtask 3.
+  #
+  #   Postponed: I got bored of it.
+  class Metadata
+    attr_reader :lines, :subtasks, :metadata
+    def initialize(lines: [], subtasks: [], metadata: {})
+      @lines, @subtasks, @metadata = lines, subtasks, metadata
+      @lines.is_a?(Array)    || raise(ArgumentError.new("Lines must be an array!"))
+      @subtasks.is_a?(Array) || raise(ArgumentError.new("Subtasks must be an array!"))
+      @metadata.is_a?(Hash)  || raise(ArgumentError.new("Metadata must be an array!"))
+    end
+
+    def []=(key, value)
+      if @metadata['Postponed'] && key == 'Failed'
+        raise ArgumentError.new("....")
+      end
+    end
+
+    def to_s
+      @lines.join("\n\n")
+      @subtasks.join("\n")
+      @metadata.reduce(Array.new) do |buffer, (key, value)|
+        buffer << "#{key}: #{value}"
+      end
+    end
+  end
+end

data/lib/pomodoro/formats/today/task/statuses.rb

@@ -0,0 +1,63 @@
+module Pomodoro::Formats::Today
+  module TaskStatuses
+    # @!group Status checking methods
+    def ended?
+      [:done, :failed].include?(@status)
+    end
+
+    def unstarted?
+      @start_time.nil? && @status == :not_done
+    end
+
+    def skipped?(time_frame)
+      self.unstarted? && time_frame.ended?
+    end
+
+    def in_progress?
+      (! @start_time.nil? && @end_time.nil?) && @status == :not_done
+    end
+
+    alias_method :started?, :in_progress?
+
+    def completed?
+      @status == :done && ! self.metadata['Reason']
+    end
+
+    def progress_made_but_not_finished?
+      @status == :done && self.metadata['Reason']
+    end
+
+    def postponed?
+      @status == :failed && self.metadata['Postponed']
+    end
+
+    def deleted?
+      @status == :failed && self.metadata['Deleted']
+    end
+
+    # @!group Status setters
+    def start!
+      @status, @start_time = :in_progress, Hour.now
+    end
+
+    def finish_for_the_day!
+      @end_time = Hour.now if @start_time
+      @status = :progress_made
+    end
+
+    def complete!
+      @end_time = Hour.now if @start_time
+      @status = :completed
+    end
+
+    def postpone!(reason, next_review)
+      @end_time = Hour.now if @start_time
+      @status = :failed
+    end
+
+    def delete!(reason)
+      @end_time = Hour.now if @start_time
+      @status = :failed
+    end
+  end
+end

data/lib/pomodoro/formats/today/task_list.rb

@@ -0,0 +1,50 @@
+require 'pomodoro/formats/today'
+
+module Pomodoro::Formats::Today
+  class TaskList
+    attr_reader :time_frame_list
+    def initialize(time_frame_list)
+      @time_frame_list = time_frame_list
+
+      time_frame_list.each do |time_frame|
+        self.define_singleton_method(time_frame.method_name) do
+          time_frame
+        end
+      end
+    end
+
+    def get_current_time_frame(current_time = Time.now)
+      @time_frame_list.find do |time_frame|
+        starting_time, closing_time = time_frame.interval
+        starting_time < current_time && (closing_time.nil? || closing_time > current_time)
+      end
+    end
+
+    include Enumerable
+    def each(&block)
+      @time_frame_list.each(&block)
+    end
+
+
+    def duration
+      self.time_frame_list.sum { |time_frame| time_frame.duration }
+    end
+
+    # def has_unfinished_tasks?
+    #   @time_frame_list.any?(&:has_unfinished_tasks?)
+    # end
+
+    def to_s
+      self.time_frame_list.reduce(nil) do |buffer, time_frame|
+        buffer ? "#{buffer}\n\n#{time_frame.to_s}" : "#{time_frame.to_s}"
+      end
+    end
+
+    def save(path)
+      data = self.to_s
+      File.open(path, 'w') do |file|
+        file.puts(data)
+      end
+    end
+  end
+end

data/lib/pomodoro/formats/today/time_frame.rb

@@ -0,0 +1,113 @@
+require 'pomodoro/exts/hour'
+require 'pomodoro/formats/today'
+
+module Pomodoro::Formats::Today
+  class TimeFrame
+    ALLOWED_OPTIONS ||= [:online, :writeable, :note, :tags]
+
+    attr_reader :name, :tasks, :interval, :options
+    attr_reader :start_time, :end_time, :header
+    def initialize(header:, start_time: nil, end_time: nil, task_list: Array.new, **shit)
+      # tag, interval_from, interval_to, options = Hash.new
+      @name, @tag, @options = header, nil, {}
+      @interval = [start_time, end_time]
+      @start_time, @end_time = start_time, end_time
+      @header = header
+      # @interval = [interval_from && Hour.parse(interval_from), interval_to && Hour.parse(interval_to)]
+      @tasks = task_list
+
+      # if @options.has_key?(:writeable) && ! @options[:writeable]
+      #   @tasks.freeze
+      # end
+
+      unless (unrecognised_options = options.keys - ALLOWED_OPTIONS).empty?
+        raise ArgumentError.new("Unrecognised options: #{unrecognised_options.inspect}")
+      end
+    end
+
+    def create_task(header, duration = nil, tags = Array.new)
+      @tasks << Task.new(header: header, tags: tags)
+    end
+
+    def unshift_task(*args)
+      @tasks.unshift(Task.new(*args))
+    end
+
+    def header
+      if @interval[0] && @interval[1]
+        [@name, "(#{@interval[0]} – #{@interval[1]})"].compact.join(' ')
+      elsif @interval[0] && ! @interval[1]
+        [@name, "(from #{@interval[0]})"].compact.join(' ')
+      elsif ! @interval[0] && @interval[1]
+        [@name, "(until #{@interval[1]})"].compact.join(' ')
+      else
+        [@name, @options[:online] && '#online'].compact.join(' ')
+      end
+    end
+
+    def to_s
+      if @tasks.empty?
+        self.header
+      else
+        ["#{self.header}", self.tasks.map(&:to_s)].join("\n")
+      end
+    end
+
+    def method_name
+      if @name
+        @name.downcase.tr(' ', '_').to_sym
+      else
+        :default
+      end
+    end
+
+    def active_task
+      self.tasks.find do |task|
+        task.in_progress?
+      end
+    end
+
+    def first_unstarted_task
+      self.tasks.find do |task|
+        task.unstarted?
+      end
+    end
+
+    def remaining_duration
+      @interval[1] && (@interval[1] - Hour.now)
+    end
+
+    include Enumerable
+    def each(&block)
+      @tasks.each do |task|
+        block.call(task)
+      end
+    end
+
+    def duration
+      self.tasks.reduce(0) do |sum, task|
+        (task.finished? && task.duration) ? sum + task.duration : sum
+      end
+    end
+
+    # def has_unfinished_tasks?
+    #   self.tasks.any? do |task|
+    #     ! task.finished?
+    #   end
+    # end
+
+
+    # def mark_active_task_as_done # TODO: WIP
+    #   #Time.now.strftime('%H:%M')
+    #   self.active_task.tags.push(:done)
+    # end
+    #
+    # def active_task
+    #   self.today_tasks.find { |task| ! task.tags.include?(:done) }
+    # end
+    #
+    # def finished_tasks
+    #   self.today_tasks.select { |task| task.tags.include?(:done) }
+    # end
+  end
+end

data/lib/pomodoro/schedule/dsl.rb

@@ -0,0 +1,68 @@
+require 'date'
+require 'pomodoro/formats/today'
+
+module Pomodoro
+  module Schedule
+    class Thing
+      def initialize(condition, &block)
+        @condition, @callable = condition, block
+      end
+
+      def true?
+        @condition.call
+      end
+
+      def call(tasks)
+        @callable.call(tasks)
+      end
+    end
+
+    class Rule < Thing
+    end
+
+    class Schedule < Thing
+      def call
+        list = @callable.call
+        TaskList.new(list)
+      end
+    end
+
+    class DSL
+      attr_reader :rules, :schedules, :today
+      def initialize(schedule_dir, today = Date.today)
+        @schedule_dir, @today = schedule_dir, today
+        @rules, @schedules = Hash.new, Hash.new
+      end
+
+      alias_method :_require, :require
+      def require(schedule)
+        path = File.expand_path("#{@schedule_dir}/#{schedule}.rb")
+        self.instance_eval(File.read(path), path)
+      rescue Errno::ENOENT # require 'pry'
+        _require schedule
+      end
+
+      def schedule(name, condition, &block)
+        @schedules[name] = Schedule.new(condition, &block)
+      end
+
+      def rule(name, condition, &block)
+        @rules[name] = Rule.new(condition, &block)
+      end
+
+      def last_day_of_a_month
+        Date.new(today.year, today.month, -1)
+      end
+
+      def last_work_day_of_a_month
+        if last_day_of_a_month.saturday?
+          last_work_day_of_a_month = last_day_of_a_month.prev_day
+        elsif last_day_of_a_month.sunday?
+          last_work_day_of_a_month = last_day_of_a_month.prev_day.prev_day
+        else
+          last_work_day_of_a_month = last_day_of_a_month
+        end
+      end
+    end
+  end
+end

data/lib/pomodoro/scheduler.rb

@@ -0,0 +1,46 @@
+require 'date'
+require 'refined-refinements/date'
+
+require 'pomodoro/schedule/dsl'
+
+module Pomodoro
+  class Scheduler
+    using RR::DateExts
+
+    def self.load(paths, today = Date.today)
+      dir = File.expand_path("#{paths.first}/..") # HACK This way we don't have to merge multiple contexts or reset its path.
+      context = Pomodoro::Schedule::DSL.new(dir, today)
+      paths.each do |path|
+        context.instance_eval(File.read(path), path)
+      end
+
+      self.new(context)
+    end
+
+    def initialize(schedule)
+      @schedule = schedule
+    end
+
+    def rules
+      @schedule.rules
+    end
+
+    def schedules
+      @schedule.schedules
+    end
+
+    def schedule_for_date(date)
+      self.schedules.each do |name, schedule|
+        return schedule if schedule.true?
+      end
+
+      return nil
+    end
+
+    def populate_from_rules(task_list)
+      self.rules.each do |rule_name, rule|
+        rule.true? && rule.call(task_list)
+      end
+    end
+  end
+end