minder 0.1

data/lib/minder/period.rb

@@ -0,0 +1,35 @@
+require 'minder/timer'
+
+module Minder
+  class Period
+    attr_accessor :minutes,
+                  :timer
+
+    def initialize(minutes: nil)
+      self.minutes = minutes
+      self.timer = Minder::Timer.new(seconds: minutes.to_i * 60)
+    end
+
+    def start!
+      Minder.play_sound('start.wav')
+      timer.start!
+    end
+
+    def complete!
+      Minder.play_sound('done.wav')
+      @status = :completed
+    end
+
+    def completed?
+      @status == :completed
+    end
+
+    def elapsed?
+      timer.completed?
+    end
+
+    def message
+      timer.to_s
+    end
+  end
+end

data/lib/minder/pomodoro_frame.rb

@@ -0,0 +1,54 @@
+require 'minder/frame'
+
+module Minder
+  class PomodoroFrame < Frame
+    def template
+      text = <<-TEXT
+<%= period.title %>
+TEXT
+
+      if period.message
+        text += <<-TEXT
+
+<%= period.message %>
+TEXT
+      end
+
+      if task_manager.started_task
+        text += <<-TEXT
+
+Working on: #{task_manager.started_task}
+TEXT
+      end
+
+      text
+    end
+
+    def period
+      pomodoro_runner.current_action
+    end
+
+    def handle_char_keypress(key)
+      event = case key
+      when ' ' then :continue
+      when 'e' then :editor
+      end
+
+      changed
+      notify_observers(event)
+    end
+
+    def handle_non_char_keypress(key)
+      event = case key
+      when 3 then :exit
+      end
+
+      changed
+      notify_observers(event)
+    end
+
+    def set_cursor_position
+      window.setpos(1, lines[0].strip.length + 2)
+    end
+  end
+end

data/lib/minder/pomodoro_period.rb

@@ -0,0 +1,13 @@
+require 'minder/period'
+
+module Minder
+  class PomodoroPeriod < Period
+    def initialize(minutes: DEFAULT_WORK_PERIOD)
+      super
+    end
+
+    def title
+      "Work period"
+    end
+  end
+end

data/lib/minder/pomodoro_runner.rb

@@ -0,0 +1,69 @@
+require 'observer'
+
+require 'minder/pomodoro_period'
+require 'minder/break_period'
+require 'minder/idle_period'
+
+module Minder
+  class PomodoroRunner
+    include Observable
+
+    attr_accessor :work_duration,
+                  :short_break_duration,
+                  :long_break_duration
+
+    attr_reader :action_count,
+                :current_action
+
+    def initialize(**options)
+      self.work_duration = options.fetch(:work_duration)
+      self.short_break_duration = options.fetch(:short_break_duration)
+      self.long_break_duration = options.fetch(:long_break_duration)
+      @action_count = 0
+      @current_action = IdlePeriod.new
+    end
+
+    def tick
+      return if !current_action.elapsed? || current_action.completed?
+
+      old_action = current_action
+      current_action.complete!
+      @current_action = IdlePeriod.new
+
+      changed
+      if old_action.is_a?(PomodoroPeriod)
+        notify_observers(:completed_work)
+      elsif old_action.is_a?(BreakPeriod)
+        notify_observers(:completed_break)
+      end
+    end
+
+    def continue
+      return unless current_action.elapsed?
+
+      advance_action
+      current_action.start!
+    end
+
+    def advance_action
+      @action_count += 1
+      changed
+
+      if action_count.odd?
+        notify_observers(:started_work)
+        @current_action = PomodoroPeriod.new(minutes: work_duration)
+      else
+        notify_observers(:started_break)
+        @current_action = BreakPeriod.new(minutes: break_duration)
+      end
+    end
+
+    def break_duration
+      if action_count % 8 == 0
+        long_break_duration
+      else
+        short_break_duration
+      end
+    end
+  end
+end

data/lib/minder/quick_add_frame.rb

@@ -0,0 +1,47 @@
+require 'minder/frame'
+
+module Minder
+  class QuickAddFrame < Frame
+    attr_accessor :input
+
+    def initialize(*)
+      super
+      self.input = ''
+    end
+
+    def template
+      <<-TEXT
+Quick add task:
+TEXT
+    end
+
+    def set_text
+      self.lines[0] += ' ' + input
+      super
+    end
+
+    def set_cursor_position
+      window.setpos(1, template.strip.length + 2 + input.length)
+    end
+
+    def handle_char_keypress(key)
+      self.input += key
+      refresh
+    end
+
+    def handle_non_char_keypress(key)
+      case key
+      when 127
+        self.input.chop!
+        refresh
+      when 10
+        changed
+        notify_observers(:add_task, { task: input })
+        self.input = ''
+        refresh
+      else
+        #Minder.pry_open(binding)
+      end
+    end
+  end
+end

data/lib/minder/scene.rb

@@ -0,0 +1,85 @@
+require 'ostruct'
+require 'minder/pomodoro_frame'
+require 'minder/message_frame'
+require 'minder/quick_add_frame'
+
+module Minder
+  class Scene
+    attr_accessor :frames
+
+    def initialize
+      self.frames = []
+    end
+
+    def setup
+      Curses.noecho
+      Curses.init_screen
+      Curses.timeout = 0
+      clear
+      Curses.refresh
+    end
+
+    def focused_frame
+      frames.find(&:focused?)
+    end
+
+    def switch_focus
+      current_index = frames.find_index(focused_frame)
+      focused_frame.unfocus
+      next_frame = frames[current_index + 1..-1].find { |frame| !frame.hidden? }
+      if next_frame
+        next_frame.focus
+      else
+        frames[0].focus
+      end
+    end
+
+    def refresh
+      frames.map(&:refresh)
+    end
+
+    def resize_frames
+      frames.map(&:resize)
+
+      available_height = Curses.lines - frames.last.height
+
+      frames.first.move(0, 0)
+      next_height = frames.first.height
+      second_frame = frames[1]
+
+      unless second_frame.hidden?
+        proposed_height = available_height - frames.first.height
+        if proposed_height < second_frame.desired_height
+          second_frame.height = proposed_height
+        else
+          second_frame.height = second_frame.desired_height
+        end
+        second_frame.move(next_height, 0)
+        next_height += second_frame.height
+      end
+
+      if next_height <= available_height
+        frames.last.move(next_height, 0)
+      else
+        frames.last.move(available_height, 0)
+      end
+    end
+
+    def redraw
+      refresh
+      resize_frames
+      refresh
+      Curses.curs_set(1)
+      focused_frame.set_cursor_position
+      focused_frame.window_refresh
+    end
+
+    def clear
+      Curses.clear
+    end
+
+    def close
+      Curses.close_screen
+    end
+  end
+end

data/lib/minder/task.rb

@@ -0,0 +1,28 @@
+require 'virtus'
+
+module Minder
+  class Task
+    include Virtus.model
+
+    attribute :description, String
+    attribute :selected, Boolean, default: false
+    attribute :started, Boolean, default: false
+
+    def start
+      self.started = true
+    end
+
+    def unstart
+      self.description.gsub!(/\* /, '')
+      self.started = false
+    end
+
+    def started?
+      super || description =~ /\* /
+    end
+
+    def to_s
+      description.gsub(/\A\* /, '')
+    end
+  end
+end

data/lib/minder/task_recorder.rb

@@ -0,0 +1,120 @@
+require 'minder/task'
+require 'fileutils'
+
+module Minder
+  class TaskRecorder
+    attr_accessor :tasks,
+                  :lines
+
+    def initialize
+      @selected_task_index = 0
+      reload
+    end
+
+    def tasks
+      @tasks ||= lines.map { |task| Task.new(description: task) }
+    end
+
+    def tasks?
+      !tasks.empty?
+    end
+
+    def add_task(task)
+      File.open(DOING_FILE, 'a') do |file|
+        file.write("#{task}\n")
+      end
+      reload
+    end
+
+    def select_next_task
+      if @selected_task_index + 1 <= tasks.length - 1
+        @selected_task_index += 1
+      else
+        @selected_task_index = 0
+      end
+    end
+
+    def select_previous_task
+      if @selected_task_index == 0
+        @selected_task_index = tasks.length - 1
+      else
+        @selected_task_index -= 1
+      end
+    end
+
+    def selected_task_index
+      @selected_task_index
+    end
+
+    def selected_task
+      tasks[selected_task_index]
+    end
+
+    def delete_task
+      lines.delete_at(selected_task_index)
+      @tasks = nil
+      write_file_with_backup
+      reload
+
+      select_previous_task
+    end
+
+    def reload
+      self.lines = File.read(DOING_FILE).strip.split("\n")
+      @tasks = nil
+    end
+
+    def complete_task
+      task = selected_task
+      delete_task
+      add_to_done_file("Finished: #{task.description}")
+    end
+
+    def add_to_done_file(text)
+      File.open(DONE_FILE, 'a') do |file|
+        file.write("[#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] #{text}\n")
+      end
+    end
+
+    def write_file_with_backup
+      FileUtils.cp(DOING_FILE, DOING_FILE + '.old')
+      write_file(DOING_FILE)
+    end
+
+    def write_file(path)
+      File.open(path, 'w') do |file|
+        tasks.each do |task|
+          line = task.to_s
+          line = "* #{line}" if task.started?
+          file.write("#{line}\n")
+        end
+      end
+    end
+
+    def start_task
+      selected_task.start
+      write_file_with_backup
+      add_to_done_file("Started: #{selected_task.description}")
+      reload
+    end
+
+    def unstart_task
+      selected_task.unstart
+      write_file_with_backup
+      add_to_done_file("Un-started: #{selected_task.description}")
+      reload
+    end
+
+    def started_task
+      tasks.find(&:started?)
+    end
+
+    def select_last_task
+      @selected_task_index = tasks.length - 1
+    end
+
+    def select_first_task
+      @selected_task_index = 0
+    end
+  end
+end

data/lib/minder/timer.rb

@@ -0,0 +1,32 @@
+require 'minder'
+
+module Minder
+  class Timer
+    attr_accessor :seconds,
+                  :start_time
+
+    def initialize(seconds: DEFAULT_WORK_PERIOD)
+      self.seconds = seconds
+    end
+
+    def start!
+      self.start_time = Time.now
+    end
+
+    def completed?
+      elapsed_time.to_i >= seconds
+    end
+
+    def elapsed_time
+      return 0 unless start_time
+
+      (Time.now - start_time)
+    end
+
+    def to_s
+      "#{Minder.formatted_time(elapsed_time)} " \
+        "(out of #{Minder.formatted_time(seconds)})"
+    end
+  end
+end
+

data/lib/minder/version.rb

@@ -0,0 +1,3 @@
+module Minder
+  VERSION = 0.1
+end

data/lib/minder.rb

@@ -0,0 +1,30 @@
+module Minder
+  DEFAULT_WORK_PERIOD = 25
+  DEFAULT_BREAK_PERIOD = 5
+  CONFIG_LOCATION = ENV['HOME'] + '/.minder.json'
+  ASSETS_LOCATION = File.expand_path(File.dirname(__FILE__) + '/../assets')
+  DOING_FILE = File.join(ENV["HOME"], '.minder', 'doing.txt')
+  DONE_FILE = File.join(ENV["HOME"], '.minder', 'done.txt')
+  def self.formatted_time(seconds)
+    minutes = (seconds / 60).to_i
+    seconds = (seconds % 60).round
+    "#{'%02d' % minutes}:#{'%02d' % seconds}"
+  end
+
+  def self.play_sound(name)
+    command = is_linux? ? 'aplay' : 'afplay'
+    spawn("#{command} #{ASSETS_LOCATION}/#{name}",
+          out: '/dev/null',
+          err: '/dev/null')
+  end
+
+  def self.is_linux?
+    RUBY_PLATFORM =~ /linux/
+  end
+
+  def self.pry_open(b)
+    Curses.close_screen
+    require 'pry'
+    b.pry
+  end
+end

data/minder.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'minder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "minder"
+  spec.version       = Minder::VERSION
+  spec.authors       = ["Joseph Method"]
+  spec.email         = ["tristil@gmail.com"]
+  spec.description   = %q{Productivity tool borrowing a little from everything.}
+  spec.summary       = %q{Combines a Pomodoro Technique runner with GTD-style task backlogs and Day One-style prompts."}
+  spec.homepage      = "http://github.com/tristil/minder"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'curses', '~> 1.0', '>= 1.0.1'
+  spec.add_runtime_dependency 'virtus', '~> 1.0', '>= 1.0.5'
+
+  spec.add_development_dependency "bundler", '~> 0'
+  spec.add_development_dependency "rspec", '~> 3.2', '>= 3.2'
+  spec.add_development_dependency "timecop", '~> 0.7', '>= 0.7.3'
+  spec.add_development_dependency "pry", '~> 0.10', '>= 0.10'
+  spec.add_development_dependency "pry-byebug", '~> 3.1', '>= 3.1.0'
+  spec.add_development_dependency 'pry-stack_explorer', '~> 0.4.9'
+
+  spec.licenses = ['MIT']
+end
+

data/spec/minder/application_spec.rb

@@ -0,0 +1,55 @@
+require 'minder/application'
+require 'tempfile'
+
+describe Minder::Application do
+  let(:config_file) do
+    Tempfile.new('minder config')
+  end
+
+  describe '#initialize' do
+    it 'sets the config' do
+      config = instance_spy('Minder::Config')
+      application = Minder::Application.new(config: config)
+      expect(application.config).to eq(config)
+    end
+  end
+
+  specify '#config_location is delegated to the config' do
+    config = instance_spy('Minder::Config', location: 'location')
+    application = Minder::Application.new(config: config)
+    expect(application.config_location).to eq('location')
+  end
+
+  describe '#run' do
+    let(:config) do
+      instance_spy(
+        'Minder::Config',
+        work_duration: 'work_duration',
+        short_break_duration: 'short_break_duration',
+        long_break_duration: 'long_break_duration')
+    end
+    let(:application) { Minder::Application.new(config: config) }
+
+    it 'runs the application' do
+      pomodoro_runner = instance_double(Minder::PomodoroRunner)
+      allow(Minder::PomodoroRunner).to receive(:new)
+        .with(work_duration: 'work_duration',
+              short_break_duration: 'short_break_duration',
+              long_break_duration: 'long_break_duration')
+        .and_return(pomodoro_runner)
+      allow(application).to receive(:system)
+      allow(application).to receive(:puts)
+      allow(STDIN).to receive(:getc).and_return(' ')
+      interval = instance_double(Minder::Interval)
+      allow(pomodoro_runner).to receive(:next_action).and_return(interval)
+
+      application.run
+
+      expect(application).to have_received(:system).with('stty raw -echo')
+      expect(application).to have_received(:system).with('stty -raw echo')
+      expect(STDIN).to have_received(:getc).with('stty -raw echo')
+      expect(pomodoro_runner).to have_received(:next_action)
+      expect(interval).to receive(:)
+    end
+  end
+end

data/spec/minder/config_spec.rb

@@ -0,0 +1,44 @@
+require 'minder/config'
+require 'tempfile'
+
+describe Minder::Config do
+  specify 'it sets location' do
+    config = Minder::Config.new('location')
+    expect(config.location).to eq('location')
+  end
+
+  describe '#load' do
+    it 'loads values from a json file if it exists' do
+      data = {
+        work_duration: 15,
+        short_break_duration: 10
+      }
+      json_file = Tempfile.new('minder json file')
+      json_file.write(JSON.dump(data))
+      json_file.seek(0)
+      config = Minder::Config.new(json_file.path)
+      config.load
+      expect(config.data).to include(
+        work_duration: 15,
+        short_break_duration: 10,
+        long_break_duration: 15)
+    end
+
+    it 'loads default values if no location is passed' do
+      config = Minder::Config.new
+      config.load
+      expect(config.data).to include(
+        work_duration: 25,
+        short_break_duration: 5,
+        long_break_duration: 15)
+    end
+  end
+
+  describe 'auto-generated methods' do
+    it 'creates a reader method for each default value key' do
+      config = Minder::Config.new
+      config.load
+      expect(config.work_duration).to eq(25)
+    end
+  end
+end

data/spec/minder/pomodoro_break_spec.rb

@@ -0,0 +1,25 @@
+require 'minder/pomodoro_break'
+
+describe Minder::PomodoroBreak do
+  describe '#run' do
+    let(:timer) { instance_spy(Minder::Timer) }
+
+    it 'runs the pomodoro' do
+      pomodoro = described_class.new(minutes: 5)
+
+      allow(Minder::Timer).to receive(:new)
+        .with(seconds: 300)
+        .and_return(timer)
+      allow(timer).to receive(:completed?).and_return(false, true)
+      allow($stdout).to receive(:flush)
+      allow(pomodoro).to receive(:puts)
+      allow(pomodoro).to receive(:print)
+
+      pomodoro.run
+
+      expect(pomodoro).to have_received(:puts).with('Break period')
+      expect(timer).to have_received(:start!)
+      expect(timer).to have_received(:tick).at_least(:once)
+    end
+  end
+end

data/spec/minder/pomodoro_runner_spec.rb

@@ -0,0 +1,3 @@
+describe Minder::PomodoroRunner do
+
+end