now-task-manager 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70c0874cdf93fd43ed8551927de6df1108063489
+  data.tar.gz: 44a53cdf68384fac811045ff7f014bf17cfb5b22
+SHA512:
+  metadata.gz: 0c1a7b2f7d86729e72459bde2c0de679e742af5a96e7f861c7a86d799cde99ab0cb417ed34f3e95867b2ff92ec06736bc91f2e43fefd8369f3b73ad1c1044be1
+  data.tar.gz: d4d178e9a047999f5ec680eda76f43959e1a67ace46e57a2f6bb46005443feaf1b953007c5ceacd1d5be66f92f3ad1923a4e9ab9a6480eb4183ef4d14ef5c60a

data/README.md

@@ -0,0 +1,66 @@
+# About
+
+[![Gem version][GV img]][Gem version]
+[![Build status][BS img]][Build status]
+[![Coverage status][CS img]][Coverage status]
+[![YARD documentation][YD img]][YARD documentation]
+
+**Now Task Manager** is a daily planner & focus app *for programmers*. It helps
+you plan your day, stay focused and track your time.
+
+It doesn't replace either GTD or the pomodoro technique, it complements them.
+(In fact there will be a [Pomodoro plugin #18](https://github.com/botanicus/now-task-manager/issues/18) at some point.)
+
+At some point I must have tried every bloody time management app there is (and let
+me tell you, there's a lot of them) and I was still disorganised and eventually
+went back to tracking my tasks in a plain text file.
+
+And that's what <abbrev title="Now Task Manager">NTM</abbrev> is using: just plain
+text files. But plain text files by themselves didn't help me: after all, that was
+what I begun with.
+
+The problem I was always facing was what to do when. As a freelancer, I can do
+generally do anything anytime. That's great on one hand, on the other hand it
+takes much more discipline. Typical problems:
+
+- Work too much time on one project and too little time on another one.
+- Starting a day with a great idea, coding half a day and then working on clients
+  projects late at night.
+- Missing incremental steps to my long-term goals, like doing every morning Spanish
+  revision.
+
+Everything started to turn around when I started to adapt what I call **time framing**:
+time framing is about splitting your day into several blocks with clear start time
+and end time and within the block doing only tasks that are related to that block.
+
+So <abbrev title="Now Task Manager">NTM</abbrev> is an automation based on my plain
+text task files where you define your schedule and then forces you to stick to it.
+
+![Workflow diagram](https://raw.githubusercontent.com/botanicus/now-task-manager/master/doc/diagram.png)
+
+Read about the [benefits](https://github.com/botanicus/now-task-manager/blob/master/doc/benefits.md).
+
+## What it's not
+
+Firstly, this is **not a project management** or **GTD system**: there is no
+concept of a project. Here it's all about chunks of time (days and time frames)
+and populating them with tasks from do-it-later lists as well as automatically.
+
+You might very well need such system and that's fine: I use GH issues just for that,
+in addition to using Pomodoro. But Pomodoro is the corner stone of my day organisation,
+GH issues are place to dump to tasks, then link them from Pomodoro.
+
+For the same reason it doesn't deal with **priorities**. If it's not a priority,
+why would you put it on today's todo list?
+
+_**Read next**: the [workflow](https://github.com/botanicus/now-task-manager/blob/master/doc/workflow.md)_
+
+[Gem version]: https://rubygems.org/gems/now-task-manager
+[Build status]: https://travis-ci.org/botanicus/now-task-manager
+[Coverage status]: https://coveralls.io/github/botanicus/now-task-manager
+[YARD documentation]: http://www.rubydoc.info/github/botanicus/now-task-manager/master
+
+[GV img]: https://badge.fury.io/rb/pomodoro.svg
+[BS img]: https://travis-ci.org/botanicus/now-task-manager.svg?branch=master
+[CS img]: https://img.shields.io/coveralls/botanicus/now-task-manager.svg
+[YD img]: http://img.shields.io/badge/yard-docs-blue.svg

data/bin/git-commit-pomodoro

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+message=$(pomodoro active git)
+git commit -m "$message"

data/bin/pomodoro

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+
+require 'pomodoro'
+require 'refined-refinements/colours'
+
+using RR::ColourExts
+
+def parse(parser_class, transformer_class, result_class, file_path)
+  input = File.read(file_path, encoding: 'utf-8')
+  tree  = parser_class.new.parse(input)
+  # .parse(input, reporter: Parslet::ErrorReporter::Deepest.new)
+  nodes = transformer_class.new.apply(tree)
+  result_class.new(nodes) unless nodes.empty?
+rescue Errno::ENOENT
+  abort "<red>File #{file_path} doesn't exist.</red>".colourise
+end
+
+def parse_today_list(config)
+  parse(Pomodoro::TodayParser, Pomodoro::TodayTransformer, Pomodoro::TaskList, config.today_path)
+end
+
+def parse_task_list(config)
+  parse(Pomodoro::TaskListParser, Pomodoro::SimpleFormat::TaskListTransformer, Pomodoro::SimpleFormat::TaskList, config.task_list_path)
+end
+
+def time_frame(config, &block)
+  today_list = parse_today_list(config)
+
+  unless current_time_frame = today_list.get_current_time_frame
+    abort "<red>There is no active time frame.</red>".colourise
+  end
+
+  block.call(today_list, current_time_frame)
+end
+
+# TODO: change this to find the first active task, ignoring the time frame.
+# Only then complain about the time frame.
+def with_active_task(config, &block)
+  time_frame(config) do |today_list, current_time_frame|
+    if active_task = current_time_frame.active_task
+      block.call(active_task)
+      today_list.save(config.today_path)
+    else
+      abort "<red>No more tasks in #{current_time_frame.desc}</red>".colourise
+    end
+  end
+end
+
+def edit_next_task_when_no_task_active(config, &block)
+  time_frame(config) do |today_list, current_time_frame|
+    if active_task = current_time_frame.active_task
+      abort "<red>There is an active task already:</red>\n#{active_task}".colourise
+    end
+
+    if next_task = current_time_frame.first_unstarted_task
+      block.call(next_task)
+      today_list.save(config.today_path)
+    else
+      abort "<red>No more tasks in #{current_time_frame.desc}</red>".colourise
+    end
+  end
+end
+
+def generate_todays_tasks(date, config)
+  require 'pomodoro/scheduler'
+
+  date_path = config.today_path(date)
+
+  return date_path if File.exist?(config.today_path)
+
+  scheduler = Pomodoro::Scheduler.load([config.schedule_path, config.routine_path], date)
+
+  schedule = scheduler.schedule_for_date(date)
+  task_list = schedule.call
+  scheduler.populate_from_rules(task_list)
+
+  main_task_list = parse_task_list(config)
+  labels = ['Tomorrow', date.strftime('%A'), date.strftime('%-d/%m'), date.strftime('%-d/%m/%Y')]
+
+  labels.each do |label|
+    if main_task_list[label]
+      main_task_list[label].tasks.each do |task|
+        puts "~ #{task}"
+        task_list.morning_ritual.create_task(task)
+        main_task_list.delete(main_task_list[label])
+      end
+    end
+  end
+
+  File.open(date_path, 'w') do |file|
+    file.puts(task_list.to_s)
+  end
+
+  main_task_list.save(config.task_list_path)
+
+  return date_path
+end
+
+# Main.
+config = Pomodoro::Config.new
+
+case ARGV.shift
+when 'edit', 'e'
+  if ARGV.empty?
+    date_path = generate_todays_tasks(Date.today, config)
+    exec("vim #{date_path}")
+  elsif ARGV.first.to_i == 2
+    date_path = generate_todays_tasks(Date.today, config)
+    exec("vim -O2 #{date_path} #{config.task_list_path}")
+  elsif ARGV.first == 'tomorrow'
+    date_path = generate_todays_tasks(Date.today + 1, config)
+    exec("vim -O2 #{date_path} #{config.task_list_path}")
+  elsif ['tasks', 't'].include?(ARGV.first)
+    exec("vim #{config.task_list_path}")
+  else
+    abort(DATA.read.colourise)
+  end
+when 'next'
+  time_frame(config) do |today_list, current_time_frame|
+    if active_task = current_time_frame.active_task
+      abort "<red>There is an active task already:</red>\n#{active_task}".colourise
+    end
+
+    if task = current_time_frame.first_unstarted_task
+      task.start
+      today_list.save(config.today_path)
+    else
+      abort "<red>No more tasks in #{current_time_frame.desc}</red>".colourise
+    end
+  end
+when 'next?'
+  time_frame(config) do |today_list, current_time_frame|
+    if active_task = current_time_frame.active_task
+      abort "<red>There is an active task already:</red>\n#{active_task}".colourise
+    end
+
+    if task = current_time_frame.first_unstarted_task
+      puts task
+    else
+      abort "<red>No more tasks in #{current_time_frame.desc}</red>".colourise
+    end
+  end
+when 'complete'
+  with_active_task(config) do |active_task|
+    require 'pry'; binding.pry ###
+    active_task.complete
+    puts active_task
+  end
+when 'postpone'
+  # Ask for metadata and comments.
+  with_active_task(config) do |active_task|
+    active_task.postpone
+    puts active_task
+  end
+when 'move_on'
+  # Ask for metadata and comments.
+  with_active_task(config) do |active_task|
+    active_task.move_on
+    puts active_task
+  end
+when 'active'
+  with_active_task(config) do |active_task|
+    case ARGV.shift
+     # git-commit-pomodoro
+     # TODO: Subtasks as well.
+    when 'git'    then puts active_task.text
+    when 'prompt' then puts active_task.text
+    when nil      then puts active_task
+    else
+      # TODO: Format with %d etc.
+    end
+  end
+when 'tick-off-next'
+  edit_next_task_when_no_task_active(config) do |next_task|
+    next_task.complete
+  end
+when 'fail-next'
+  print "<bold>Why?</bold> ".colourise
+  reason = STDIN.readline.chomp
+  edit_next_task_when_no_task_active(config) do |next_task|
+    next_task.fail(reason)
+  end
+when 'postpone-next'
+  print "<bold>Why?</bold> ".colourise
+  reason = STDIN.readline.chomp
+  print "<bold>When do you want to review?</bold> Defaults to tomorrow. ".colourise
+  review_at = STDIN.readline.chomp
+  edit_next_task_when_no_task_active(config) do |next_task|
+    next_task.postpone(reason, review_at.empty? ? 'Tomorrow' : review_at)
+  end
+when '+'
+  task_list = parse_task_list(config)
+  task_list['Later'] ||= Array.new
+  task_list['Later'] << ARGV.join(' ')
+  task_list.save(config.task_list_path)
+when 'console', 'c'
+  today = parse_today_list(config)
+  tasks = parse_task_list(config)
+  require 'pry'; binding.pry
+when 'tools'
+  if ARGV.shift == 'workdays'
+    start_date = Date.new(2018, 12, 1)
+    end_date   = Date.new(2018, 12, 31)
+    work_days = (start_date..end_date).reduce(0) do |sum, date|
+      sum += 1 unless date.saturday? || date.sunday?; sum
+    end
+    puts "~ There are #{work_days} (without any bank holidays) in 2018."
+    # TODO: Per-month breakdown.
+  end
+when 'bitbar'
+  require 'pomodoro/commands/bitbar'
+  today_list = parse_today_list(config)
+  task_list  = parse_task_list(config)
+  Pomodoro::Commands::BitBar.main(today_list, task_list)
+when 'help', '-h', '--help'
+  puts(DATA.read.colourise)
+else
+  abort(DATA.read.colourise)
+end
+
+__END__
+
+<red.bold>:: Pomodoro ::</red.bold>
+
+pomodoro <green>edit</green>, pomodoro <green>e</green>
+  <bright_black>pomodoro e</bright_black> Edit the today task file, creating it if it doesn't exist.
+  <bright_black>pomodoro e <yellow>2</yellow></bright_black> Edit both the today task file and tasks (in a split screen).
+  <bright_black>pomodoro e <yellow>tasks</yellow></bright_black> (or just <yellow>t</yellow>) Open the task file.
+  <bright_black>pomodoro e <yellow>tomorrow</yellow></bright_black> Plan tomorrow.
+
+pomodoro <magenta>next</magenta> <bright_black># Start a new task.</bright_black>
+pomodoro <magenta>complete</magenta> <bright_black># Complete the active task.</bright_black>
+pomodoro <magenta>postpone</magenta> <bright_black># Postpone the active task.</bright_black>
+pomodoro <magenta>move_on</magenta> <bright_black># Move on from the active task. Mark its end time, but don't set it as completed.</bright_black>
+
+pomodoro <green>next?</green> <bright_black># Print the next task.</bright_black>
+pomodoro <green>active</green> <bright_black># Print the active task.</bright_black>
+
+pomodoro <magenta>tick-off-next</magenta> <bright_black># ...</bright_black>
+pomodoro <magenta>fail-next</magenta> <bright_black># ...</bright_black>
+pomodoro <magenta>postpone-next</magenta> <bright_black># ...</bright_black>
+
+pomodoro <red>+</red> [strings]<bright_black> # Add a task for later.</bright_black>
+
+pomodoro <yellow>console</yellow>, pomodoro <yellow>c</yellow> <bright_black># Load the tasks and launch IRB.</bright_black>
+pomodoro <yellow>bitbar</yellow> <bright_black># Print output for BitBar.</bright_black>

data/doc/benefits.md

@@ -0,0 +1,91 @@
+_This document is WIP._
+
+- Separating planning from execution.
+- Predictable schedules.
+- Task statuses. Where did you ended, why was it postponed and how long for?
+
+don't let your work and errands kill your personal objectives. Learning Spanish etc.
+
+plan, review
+scrum uses time framing as well (sprints)
+time framing here is different: it's not about deliverables (you can work on a project ad infinitum), it's about the routines and project scheduling (it's all bottom-up).
+
+USE POMODORO WITHIN for durations? This can be available via plugins.
+Example: pomodoros are not useful for everything. Like going to a bank,
+you never know how long it's going to take (esp. if you live in Poland).
+The only thing that is certain is that you have to fit it within a time frame,
+because you have to get your client's work done.
+
+I'm not a time management expert, but this is the practical solution that made my life infinitely more organised.
+
+- Schedules, task archive.
+- Increase awareness.
+- No skipping.
+- End-of-the day/week reports for clients (incl. how much to charge).
+- Offlining.
+- Make your work easier with `git commit-pomodoro`.
+
+
+_Time management technique based on time framing and a command-line task management tool._
+
+This is something between GTD and the pomodoro technique: it has part of the depth of GTD and part of the immediate action management approach of pomodoro. It is a full-circle task management method.
+
+It does also time tracking which can be used to count actual time worked for clients.
+
+## Benefits
+
+### Holistic
+
+I tried pomodoro and it's great, but it doesn't see the big picture.
+
+The pomodoro technique is great to force you to do the work and not procrastinating.
+
+It doesn't help you to keep several client projects in the air while you have your
+personal goals and responsibilities.
+
+- Holistic. It's not just for the work or just for home.
+- Defaults. Don't think.
+- Automatically tracking time for clients.
+
+## It doesn't make you think
+
+Tasks are sequential. You cannot choose which task to work on next. The next task down the list is the one that's coming next.
+
+Schedules are automatic.
+
+Will power limited.
+
+## Rich data
+
+**Time tracking** (optional): Time tracking is useful if you are paid for your time or if you want to run any useful stats.
+
+Task **status** and **metadata**
+
+**Journaling**
+
+## Data is yours
+
+The data are in simple plain text and you get a Ruby library to parse them and do whatever you want.
+
+For instance let's see how much time have I spent on admin in the first quarter of 2017:
+
+```ruby
+require 'pomodoro'
+
+Pomodoro.load('2017/{1,2,3}').each do |task_list|
+  task_list.reduce(0) do |sum, time_frame|
+    if time_frame.tags.include?(:admin)
+      sum + time_frame.duration
+    else
+      sum
+    end
+  end
+end
+```
+
+Or you can want to know how good your estimates are. You've been adding a custom
+metadata such as `Estimate: 4h` to your tasks. Now you can go and compare the estimate
+with the actual duration of the task.
+
+Read the [workflow](https://github.com/botanicus/now-task-manager/blob/master/doc/workflow.md)
+to understand how it works.

data/doc/bitbar.md

@@ -0,0 +1,2 @@
+- BitBar: show each project TODO.
+- colour of a time frame based on how much time left.

data/doc/curses.md

@@ -0,0 +1,5 @@
+https://github.com/thibaudgg/rb-fsevent
+
+- Keep an eye on time frames changing.
+- Keep an eye on tasks scheduled for specific time.
+- Run the timer for tasks with given duration.

data/doc/example/rules.rb

@@ -0,0 +1,7 @@
+time_frame(/morning routine/i) do |time_frame|
+  time_frame.create_task('Headspace.')
+end
+
+time_frame(/admin/i) do |time_frame|
+  time_frame.create_task('Inbox 0.')
+end

data/doc/formats/scheduled.md

@@ -0,0 +1,32 @@
+This format is used to store **scheduled tasks**: tasks that will be done later
+or in a certain context.
+
+```
+Tomorrow
+- Buy milk. #errands
+- [9:20] Call with Mike.
+
+Prague
+- Pick up my shoes. #errands
+```
+
+# Currently unsupported
+
+- **Labels**. Labels allow us to match tasks with _named_ time frames.
+  See [#8](https://github.com/botanicus/now-task-manager/issues/8).
+
+```
+- ADM: Catch up with Eva.
+```
+
+# Intentionally unsupported
+
+- **Comments**. I want to keep the format simple and the task file small.
+  Every time there was something like comments, the file bloated uncontrollably.
+- **Task formatting**. Task is a string, it doesn't recognise any structures within.
+  Therefore, anything you can fit in to a line will be the task body. So you can
+  put anything that {Pomodoro::Formats::Today} supports such as scheduled times
+  and tags.
+
+_For more details about the format see
+{https://github.com/botanicus/now-task-manager/blob/master/spec/pomodoro/formats/scheduled/parser/parser_spec.rb parser_spec.rb}._