now-task-manager 0.1.0

data/lib/pomodoro/exts/hour.rb

@@ -0,0 +1,63 @@
+class Hour
+  def self.parse(string)
+    hours, minutes = string.split(':')
+    self.new(hours.to_i, minutes.to_i)
+  end
+
+  def self.now
+    now = Time.now
+    self.new(now.hour, now.min)
+  end
+
+  attr_reader :minutes
+  def initialize(hours, minutes = 0)
+    @minutes = (hours * 60) + minutes
+  end
+
+  [:+, :-].each do |method_name|
+    define_method(method_name) do |hour_or_minutes|
+      if hour_or_minutes.is_a?(self.class)
+        self.class.new(0, @minutes.send(method_name, hour_or_minutes.minutes))
+      elsif hour_or_minutes.is_a?(Integer)
+        self.class.new(0, @minutes.send(method_name, hour_or_minutes))
+      else
+        raise TypeError.new
+      end
+    end
+  end
+
+  def hours
+    if (@minutes / 60).round > (@minutes / 60)
+      (@minutes / 60).round - 1
+    else
+      (@minutes / 60).round
+    end
+  end
+
+  # Currently unused, but it might be in the future.
+  # def *(rate)
+  #   (@minutes * (rate / 60.0)).round(2)
+  # end
+
+  [:==, :eql?, :<, :<=, :>, :>=, :<=>].each do |method_name|
+    define_method(method_name) do |anotherHour|
+      if anotherHour.is_a?(self.class)
+        self.minutes.send(method_name, anotherHour.minutes)
+      elsif anotherHour.is_a?(Time)
+        self.send(method_name, Hour.now)
+      else
+        raise TypeError.new("#{self.class}##{method_name} expects #{self.class} or Time object.")
+      end
+    end
+  end
+
+  def inspect
+    "#{self.hours}:#{format('%02d', self.minutes_over_the_hour)}"
+  end
+  alias_method :to_s, :inspect
+
+  protected
+  def minutes_over_the_hour
+    @minutes - (self.hours * 60)
+  end
+end

data/lib/pomodoro/formats/scheduled.rb

@@ -0,0 +1,37 @@
+require 'parslet'
+require 'parslet/convenience' # parse_with_debug
+
+module Pomodoro
+  module Formats
+    # {include:file:doc/formats/scheduled.md}
+    module Scheduled
+      # The entry point method for parsing this format.
+      #
+      # @param string [String] string in the scheduled task list format
+      # @return [TaskList, nil]
+      #
+      # @example
+      #   require 'pomodoro/formats/scheduled'
+      #
+      #   task_list = Pomodoro::Formats::Scheduled.parse <<-EOF.gsub(/^\s*/, '')
+      #     Tomorrow
+      #     - Buy milk. #errands
+      #     - [9:20] Call with Mike.
+      #
+      #     Prague
+      #     - Pick up my shoes. #errands
+      #   EOF
+      # @since 1.0
+      def self.parse(string)
+        tree = Parser.new.parse_with_debug(string)
+        nodes = Transformer.new.apply(tree)
+        TaskList.new(nodes) unless nodes.empty?
+      end
+    end
+  end
+end
+
+require 'pomodoro/formats/scheduled/parser/parser'
+require 'pomodoro/formats/scheduled/parser/transformer'
+require 'pomodoro/formats/scheduled/task_list'
+require 'pomodoro/formats/scheduled/task_group'

data/lib/pomodoro/formats/scheduled/parser/parser.rb

@@ -0,0 +1,26 @@
+require 'parslet'
+require 'pomodoro/formats/scheduled'
+
+module Pomodoro::Formats::Scheduled
+  # @api private
+  class Parser < Parslet::Parser
+    rule(:header) {
+      # match['^\n'].repeat # This makes it hang!
+      (str("\n").absent? >> any).repeat(1).as(:header) >> str("\n")
+    }
+
+    rule(:task) {
+      str('- ') >> match['^\n'].repeat.as(:task) >> str("\n").repeat
+    }
+
+    rule(:task_group) {
+      (header >> task.repeat.as(:task_list)).as(:task_group)
+    }
+
+    rule(:task_groups) {
+      task_group.repeat(0)
+    }
+
+    root(:task_groups)
+  end
+end

data/lib/pomodoro/formats/scheduled/parser/transformer.rb

@@ -0,0 +1,21 @@
+require 'parslet'
+require 'pomodoro/formats/scheduled'
+
+module Pomodoro::Formats::Scheduled
+  # @api private
+  class Transformer < Parslet::Transform
+    rule(task: simple(:task)) { task.to_s }
+
+    # Doesn't work. Has multiple keys by the way.
+    rule(header: simple(:header)) { header.to_s }
+
+    rule(task_group: subtree(:task_group)) {
+      options = {
+        header: task_group[:header].to_s,
+        tasks:  task_group[:task_list]
+      }
+
+      TaskGroup.new(**options)
+    }
+  end
+end

data/lib/pomodoro/formats/scheduled/task_group.rb

@@ -0,0 +1,40 @@
+module Pomodoro::Formats::Scheduled
+  class TaskGroup
+    # @since 1.0
+    attr_reader :header, :tasks
+
+    # @param header [String] header of the task group.
+    # @param tasks [Array<String>] tasks of the group.
+    # @since 1.0
+    #
+    # @example
+    #   require 'pomodoro/formats/scheduled'
+    #
+    #   tasks = ['Buy milk. #errands', '[9:20] Call with Mike.']
+    #   group = Pomodoro::Formats::Scheduled::TaskGroup.new(header: 'Tomorrow', tasks: tasks)
+    def initialize(header:, tasks: Array.new)
+      @header, @tasks = header, tasks
+    end
+
+    # Add a task to the task group.
+    #
+    # @since 1.0
+    def <<(task)
+      @tasks << task unless @tasks.include?(task)
+    end
+
+    # Remove a task from the task group.
+    #
+    # @since 1.0
+    def delete(task)
+      @tasks.delete(task)
+    end
+
+    # Return a scheduled task list formatted string.
+    #
+    # @since 1.0
+    def to_s
+      [@header, @tasks.map { |task| "- #{task}" }, nil].flatten.join("\n")
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Pomodoro::Formats::Scheduled
+  class TaskList
+    include Enumerable
+
+    # List of {TaskGroup task groups}. Or more precisely objects responding to `#header` and `#tasks`.
+    # @since 1.0
+    attr_reader :data
+
+    # @param [Array<TaskGroup>] data List of task groups.
+    #   Or more precisely objects responding to `#header` and `#tasks`.
+    # @raise [ArgumentError] if data is not an array or if its content doesn't
+    #   respond to `#header` and `#tasks`.
+    #
+    # @example
+    #   require 'pomodoro/formats/scheduled'
+    #
+    #   tasks = ['Buy milk. #errands', '[9:20] Call with Mike.']
+    #   group = Pomodoro::Formats::Scheduled::TaskGroup.new(header: 'Tomorrow', tasks: tasks)
+    #   list  = Pomodoro::Formats::Scheduled::TaskList.new([group])
+    # @since 1.0
+    def initialize(data)
+      @data = data
+
+      unless data.is_a?(Array) && data.all? { |item| item.respond_to?(:header) && item.respond_to?(:tasks) }
+        raise ArgumentError.new("Data is supposed to be an array of TaskGroup instances.")
+      end
+    end
+
+    # Find a task group that matches given header.
+    #
+    # @return [TaskGroup, nil] matching the header.
+    # @since 1.0
+    #
+    # @example
+    #   # Using the code from the initialiser.
+    #   list['Tomorrow']
+    def [](header)
+      @data.find do |task_group|
+        task_group.header == header
+      end
+    end
+
+    # Add a task group onto the task list.
+    #
+    # @raise [ArgumentError] if the task group is already in the list.
+    # @param [TaskGroup] task_group the task group.
+    # @since 1.0
+    def <<(task_group)
+      if self[task_group.header]
+        raise ArgumentError.new("Task group with header #{task_group.header} is already on the list.")
+      end
+
+      @data << task_group
+    end
+
+    # Remove a task group from the task list.
+    #
+    # @param [TaskGroup] task_group the task group.
+    # @since 1.0
+    def delete(task_group)
+      @data.delete(task_group)
+    end
+
+    # Iterate over the task groups.
+    #
+    # @yieldparam [TaskGroup] task_group
+    # @since 1.0
+    def each(&block)
+      @data.each(&block)
+    end
+
+    # Return a scheduled task list formatted string.
+    #
+    # @since 1.0
+    def to_s
+      @data.map(&:to_s).join("\n")
+    end
+
+    # Save scheduled task list formatted string into a file.
+    #
+    # @param [String] destination_path
+    # @since 1.0
+    def save(destination_path)
+      data = self.to_s
+      File.open(destination_path, 'w') do |file|
+        file.puts(data)
+      end
+    end
+  end
+end

data/lib/pomodoro/formats/today.rb

@@ -0,0 +1,12 @@
+module Pomodoro
+  module Formats
+    module Today
+    end
+  end
+end
+
+require 'pomodoro/formats/today/task_list'
+require 'pomodoro/formats/today/time_frame'
+require 'pomodoro/formats/today/task'
+require 'pomodoro/formats/today/parser/parser'
+require 'pomodoro/formats/today/parser/transformer'

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

@@ -0,0 +1,26 @@
+module Pomodoro::Formats::Today
+  class Formatter
+    STATUS_SYMBOLS ||= {
+      # Unfinished statuses.
+      # Unstarted can be either tasks to be started,
+      # or tasks skipped when time frame changed.
+      unstarted: '-', in_progress: '-',
+
+      # maybe status :finished and :unfinished, but :unfinished would require Postponed/Deleted etc. (check dynamically)
+      # Finished, as in done for the day.
+      completed: '✔', progress_made: '✔', postponed: '✘', deleted: '✘'
+    }
+
+    def self.format(task)
+      output = [STATUS_SYMBOLS[self.status]]
+      if @start_time || @end_time
+        output << "[#{self.class.format_interval(@start_time, @end_time)}]"
+      else
+        output << "[#{@duration}]" unless @duration == DEFAULT_DURATION
+      end
+      output << @body
+      output << @tags.map { |tag| "##{tag}"}.join(' ') unless @tags.empty?
+      output.join(' ')
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'parslet'
+require 'pomodoro/formats/today'
+
+module Pomodoro::Formats::Today
+  class Parser < Parslet::Parser
+    # Primitives.
+    rule(:integer)         { match['0-9'].repeat(1) }
+
+    rule(:nl)              { str("\n").repeat(1) }
+    rule(:nl_or_eof)       { any.absent? | nl.maybe }
+
+    rule(:space)           { match('\s').repeat(1) }
+    rule(:space?)          { space.maybe }
+
+    rule(:lparen)          { str('(') }
+    rule(:rparen)          { str(')') }
+    rule(:time_delimiter)  { match['-–'] }
+    rule(:colon)           { str(':') }
+
+    rule(:hour)            { (integer.repeat >> (colon >> integer).maybe).as(:hour) }
+    rule(:hour_strict)     { (integer.repeat >> colon >> integer).as(:hour) }
+    rule(:indent)          { match['-✓✔✕✖✗✘'].as(:indent).repeat(1, 1) >> space }
+
+    rule(:task_desc)       { (match['#\n'].absent? >> any).repeat.as(:desc) }
+    rule(:time_frame_desc) { (match['(\n'].absent? >> any).repeat.as(:desc) }
+    # rule(:task_desc)       { (str(' #').absent? >> match['^\n']).repeat.as(:desc) }
+    # rule(:time_frame_desc) { (str(' (').absent? >> match['^\n']).repeat.as(:desc) }
+    # rule(:task_desc)       { (str("\n").absent? >> str(' #').absent? >> any).repeat.as(:desc) }
+    # rule(:time_frame_desc) { (str("\n").absent? >> str(' (').absent? >> any).repeat.as(:desc) }
+
+    rule(:tag)             { str('#') >> match['^\s'].repeat.as(:tag) >> space? }
+
+    rule(:duration) do
+      # ✔ 9:20
+      # ✔ 9:20–10:00
+      # ✔ started at 9:20 (this is not the same as just 9:20)
+      # ✖ 9-10
+      #   There was an issue with parsing that compared to 9 as duration.
+      (hour_strict.as(:start_time) >> (time_delimiter >> hour_strict.as(:end_time)).maybe) | str('started at') >> hour_strict.as(:start_time)
+    end
+
+    rule(:task_time_info) do
+      str('[') >> (duration | integer.as(:duration)) >> str(']') >> space
+    end
+
+    rule(:metadata) { (str("\n").absent? >> any).repeat.as(:line) }
+
+    rule(:task_body) { indent >> task_time_info.maybe >> task_desc >> tag.repeat }
+    rule(:metadata_block) { (nl >> str('  ') >> metadata).repeat(0) }
+
+    rule(:task) do
+      (task_body >> metadata_block).as(:task) >> nl.maybe # replaced nl_or_eof to fix the hang.
+      # IMPORTANT NOTE: nl.maybe is because the tag definition eats up \n's for unknown reason.
+    end
+
+    rule(:time_range) do
+      hour.as(:start_time) >> space? >> time_delimiter >> space? >> hour.as(:end_time)
+    end
+
+    rule(:time_from) do
+      (str('from') | str('after')) >> space >> hour.as(:start_time)
+    end
+
+    rule(:time_frame_header) do
+      time_frame_desc >> (lparen >> (time_range | time_from) >> rparen).maybe >> nl # replaced nl_or_eof to fix the hang.
+    end
+
+    rule(:time_frame_with_tasks) { (time_frame_header >> task.repeat.as(:task_list)).as(:time_frame) } # ...
+    rule(:time_frames_with_tasks) { time_frame_with_tasks.repeat(0) }
+
+    root(:time_frames_with_tasks)
+  end
+end

data/lib/pomodoro/formats/today/parser/transformer.rb

@@ -0,0 +1,65 @@
+require 'parslet'
+require 'pomodoro/exts/hour'
+require 'pomodoro/formats/today'
+
+module Pomodoro::Formats::Today
+  class Transformer < Parslet::Transform
+    STATUS_MAPPING ||= {
+      finished: ['✓', '✔', '☑'],
+      failed:   ['✕', '☓', '✖', '✗', '✘', '☒'],
+      wip:      ['☐', '⛶', '⚬']
+    }
+
+    rule(body: simple(:body)) {
+      {body: body.to_s.strip}
+    }
+
+    rule(duration: simple(:duration)) {
+      {duration: Integer(duration)}
+    }
+
+    rule(hour: simple(:hour_string)) {
+      Hour.parse(hour_string.to_s)
+    }
+
+    rule(tag: simple(:tag)) {
+      {tag: tag.to_sym}
+    }
+
+    rule(indent: simple(:char)) {
+      status, _ = Task::STATUS_MAPPING.find { |status, i| i.include?(char) }
+      {status: status}
+    }
+
+    rule(task: subtree(:hashes)) {
+      data = hashes.reduce(Hash.new) do |buffer, hash|
+        key = hash.keys.first
+        if buffer.has_key?(key)
+          buffer.merge(key => [buffer[key], hash[key]].flatten)
+        else
+          buffer.merge(hash)
+        end
+      end
+
+      if data[:tag]
+        data[:tags] = [data.delete(:tag)].flatten
+      end
+
+      if data[:line]
+        data[:lines] = [data.delete(:line)].flatten
+      end
+
+      begin
+        Task.new(**data)
+      rescue ArgumentError => error
+        message = [error.message, "Arguments were: #{data.inspect}"].join("\n")
+        raise ArgumentError.new(message)
+      end
+    }
+
+    rule(time_frame: subtree(:data)) {
+      data[:body] = data.delete(:desc).to_s.strip # WTH? All the other nodes are processed correctly?
+      TimeFrame.new(**data)
+    }
+  end
+end