medo 0.1.0

data/lib/medo/json_task_reader.rb

@@ -0,0 +1,31 @@
+require 'medo/task_reader'
+require 'json'
+require 'time'
+
+module Medo
+  class JsonTaskReader < TaskReader
+    def initialize(input_stream)
+      super()
+      @input_stream = input_stream
+    end
+
+    def read
+      tasks = []
+      JSON.parse(@input_stream.read).map do |task_attributes|
+        instantiate_task(task_attributes)
+      end
+    end
+
+    private
+
+    def instantiate_task(attributes)
+      attributes["created_at"] = Time.parse(attributes["created_at"])
+      if attributes["done"]
+        attributes["completed_at"] = Time.parse(attributes["completed_at"])
+      end
+      Task.from_attributes(attributes)
+    end
+  end
+end
+
+

data/lib/medo/json_task_writer.rb

@@ -0,0 +1,33 @@
+require 'medo/task_writer'
+require 'json'
+
+module Medo
+  class JsonTaskWriter < TaskWriter
+    def initialize(output_stream = STDOUT)
+      super()
+      @output_stream = output_stream
+    end
+
+    def write
+      tasks = @tasks.map { |t| TaskPresenter.new(t).as_json }.to_json
+      @output_stream.write(tasks)
+    end
+
+    class TaskPresenter
+      def initialize(task)
+        @task = task
+      end
+
+      def as_json
+        {
+          :done         => @task.done?,
+          :description  => @task.description,
+          :created_at   => @task.created_at,
+          :completed_at => (@task.completed_at if @task.done?),
+          :notes        => @task.notes
+        }
+      end
+    end
+  end
+end
+

data/lib/medo/support.rb

@@ -0,0 +1,6 @@
+module Medo
+  module Support
+  end
+end
+
+require 'medo/support/decorator'

data/lib/medo/support/decorator.rb

@@ -0,0 +1,40 @@
+module Medo
+  module Support
+
+    ##
+    # This module is intended to extend other (decorator) modules
+    #
+    # Usage:
+    #  
+    #   module MyDecorator
+    #     extend Support::Decorator
+    #
+    #     after_decorate do |arg1, arg2|
+    #       @arg1, @arg2 = arg1, arg2
+    #       ...
+    #     end
+    #
+    #     #methods go here
+    #   end
+    #
+    #   decorated = Object.new
+    #   MyDecorator.decorate(decorate, :foo, :bar)
+    #
+    # :foo and :bar go to after_decorate block, which is evaluated 
+    # on decorated object
+    #
+    # after_update block is optional
+    #
+    module Decorator
+      def decorate(base, *args)
+        base.extend(self)
+        base.instance_exec(*args, &@after_decorate_block) if defined? @after_decorate_block
+        base
+      end
+
+      def after_decorate(&block)
+        @after_decorate_block = block
+      end
+    end
+  end
+end

data/lib/medo/task.rb

@@ -0,0 +1,63 @@
+module Medo
+  class Task
+    include Comparable
+
+    attr_reader :description, :created_at, :completed_at, :notes
+
+    class << self
+      attr_accessor :clock
+
+      def from_attributes(attributes)
+        task = Task.new(attributes.delete("description"), attributes)
+        task.instance_eval do
+          @created_at = attributes["created_at"] or raise ArgumentError, "Missing created_at"
+          @done = attributes["done"]
+          @completed_at = attributes["completed_at"] or raise ArgumentError, "Missing completed_at" if @done
+        end
+        task
+      end
+    end
+    self.clock = Time
+
+    def initialize(description, options = {})
+      @description  = description.to_s.strip
+      raise ArgumentError, "No description given!" if @description.empty?
+      @created_at   = clock.now
+      @completed_at = nil
+      @notes        = parse_notes(options["notes"] || options[:notes])
+    end
+
+    def <=>(other)
+      unless other.kind_of?(Task)
+        raise ArgumentError, "comparison of #{self.class.name} with #{other.class.name} failed"
+      end
+
+      case [self.completed_at.nil?, other.completed_at.nil?]
+      when [true, true]   then (self.created_at <=> other.created_at) * -1
+      when [false, false] then (self.completed_at <=> other.completed_at) * -1
+      when [true, false]  then -1
+      when [false, true]  then 1
+      end
+    end
+
+    def done
+      @completed_at = clock.now
+      @done         = true
+    end
+
+    def done?
+      !!@done
+    end
+
+    private
+
+    def clock
+      self.class.clock
+    end
+
+    def parse_notes(notes)
+      Array(notes).map { |n| n.to_s.strip }.reject(&:empty?)
+    end
+  end
+end
+

data/lib/medo/task_reader.rb

@@ -0,0 +1,8 @@
+module Medo
+  class TaskReader
+    def read
+      raise NotImplementedError
+    end
+  end
+end
+

data/lib/medo/task_writer.rb

@@ -0,0 +1,21 @@
+module Medo
+  class TaskWriter
+    def initialize
+      @tasks = []
+    end
+
+    def add_task(*tasks)
+      @tasks += tasks.flatten
+    end
+    alias add_tasks add_task
+
+    def tasks_to_write
+      @tasks.dup
+    end
+
+    def write
+      raise NotImplementedError
+    end
+  end
+end
+

data/lib/medo/terminal.rb

@@ -0,0 +1,6 @@
+require 'gli/terminal'
+
+module Medo
+  Terminal = GLI::Terminal
+end
+

data/lib/medo/text_task_writer.rb

@@ -0,0 +1,137 @@
+require 'medo/task_writer'
+require 'medo/terminal'
+
+module Medo
+  class TextTaskWriter < TaskWriter
+    def initialize(output_stream = STDOUT)
+      super()
+      @output_stream = output_stream
+    end
+
+    def write
+      return puts "There are no tasks left!" if @tasks.empty?
+
+      presented_active_tasks    = present_tasks(active_tasks)
+      presented_completed_tasks = present_tasks(completed_tasks)
+
+      max_task_length = (presented_active_tasks + presented_completed_tasks).map do |t| 
+        t.to_s.split("\n").map(&:size).max
+      end.max
+
+      max_output_width = [Terminal.instance.size.first, max_task_length].min
+    
+      presented_active_tasks.each do |t|
+        @output_stream.puts t.to_s(max_output_width)
+      end
+
+      if presented_active_tasks.any? and presented_completed_tasks.any?
+        @output_stream.puts "-" * max_output_width
+      end
+
+      presented_completed_tasks.each do |t|
+        @output_stream.puts t.to_s(max_output_width)
+      end
+    end
+
+    private
+
+    def active_tasks
+      @tasks.reject(&:done?).sort
+    end
+
+    def completed_tasks
+      @tasks.select(&:done?).sort
+    end
+
+    def present_tasks(tasks)
+      tasks.map { |t| TaskPresenter.new(t) }
+    end
+
+    class TaskPresenter
+
+      class Components < Struct.new(:done, :description, :time, :notes); end
+
+      def initialize(task)
+        @task = task
+      end
+
+      def description(length = nil, options = {})
+        if length
+          break_line_to_fit(@task.description, length, options)
+        else
+          @task.description
+        end
+      end
+
+      def time
+        format = "%H:%M"
+        if @task.done?
+          "[#{@task.completed_at.strftime(format)}]"
+        else
+          "(#{@task.created_at.strftime(format)})"
+        end
+      end
+
+      def notes(length = nil, options = {})
+        return "" if @task.notes.empty?
+        "\n\n" + @task.notes.map do |n|
+          if length
+            break_line_to_fit(n, length, options)
+          else
+            n.rjust(n.size + done.size + 1)
+          end
+        end.join("\n") + "\n\n"
+      end
+      
+      def done
+        "[#{@task.done? ? '+' : ' '}]"
+      end
+
+      def to_s(length = nil)
+        c = components(length)
+        "#{c.done} #{c.description} #{c.time}#{c.notes}"
+      end
+
+      private
+
+      def components(length = nil)
+        if length
+          description_length = length - done.length - time.length - 2
+          description_padding = done.length + 1
+          formatted_description = description(description_length, :left_padding => description_padding)
+
+          notes_length = length - done.length - 1
+          notes_first_line_padding = done.length + 1
+          notes_padding = notes_first_line_padding + 2
+          formatted_notes = notes(notes_length, :first_line_padding => notes_first_line_padding, :left_padding => notes_padding)
+
+          Components.new(done, formatted_description, time, formatted_notes)
+        else
+          Components.new(done, description, time, notes)
+        end
+      end
+
+      def break_line_to_fit(str, length, options = {})
+        first_line_padding = options[:first_line_padding]
+        left_padding       = options[:left_padding]
+        padding_diff       = (left_padding - first_line_padding) if first_line_padding && left_padding
+        available_length   = length - padding_diff.to_i
+
+        lines = str.gsub(/(.{1,#{available_length}})(?:\s+|\Z)|(.{1,#{available_length}})/m, "\\1\\2\n").split("\n")
+
+        lines.map! do |line|
+          line.strip.ljust(available_length).rjust(available_length + left_padding.to_i) 
+        end
+
+        lines[0] = lines.first.strip.ljust(length).rjust(length + first_line_padding.to_i)
+        lines.join("\n")
+      end
+    end
+
+  end
+end
+
+Dir.glob(File.dirname(__FILE__) + '/text_task_writer/decorators/*_decorator.rb') do |decorator|
+  require decorator
+end
+

data/lib/medo/text_task_writer/decorators/colors_decorator.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rainbow'
+
+module Medo
+  class TextTaskWriter
+    module Decorators
+      module ColorsDecorator
+        extend Support::Decorator
+
+        private
+
+        def present_tasks(tasks)
+          super.each { |t| TaskColors.decorate(t) }
+        end
+
+        module TaskColors
+          extend Support::Decorator
+
+          def to_s(length = nil)
+            c = components(length)
+            "#{c.done.color(:red)} #{c.description.color(:black)} #{c.time.color(:yellow)}#{c.notes}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/medo/text_task_writer/decorators/numbers_decorator.rb

@@ -0,0 +1,37 @@
+require 'medo/support/decorator'
+
+module Medo
+  class TextTaskWriter
+    module Decorators
+      module NumbersDecorator
+        extend Support::Decorator
+
+        def present_tasks(tasks)
+          max_tasks_count = [active_tasks.count, completed_tasks.count].max
+          super.each_with_index.map do |t, i|
+            TaskNumbers.decorate(t, i + 1, max_tasks_count)
+          end
+        end
+
+        module TaskNumbers
+          extend Support::Decorator
+
+          after_decorate do |number, total|
+            @number        = number
+            @number_length = total.to_s.size
+          end
+
+          def number
+            format = "%-#{@number_length + 1}s"
+            format % (@task.done? ? "" : "#@number.")
+          end
+
+          def done
+            "#{number} #{super}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/lib/file_task_storage_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'medo/file_task_storage'
+
+describe FileTaskStorage do
+  before(:each) do
+    verbosity, $VERBOSE = $VERBOSE, nil
+    load 'fileutils.rb'
+    $VERBOSE = verbosity
+  end
+
+  describe "#initialize" do
+    it "should touch a storage file, so it is created if not exists" do
+      FileUtils.should_receive(:touch)
+      FileTaskStorage.new("f")
+    end
+  end
+
+  describe "#read" do
+    it "return empty array on error" do
+      class Reader; def read; raise; end; end
+      FileTaskStorage.new("f", Reader, Class).read.should ==  []
+    end
+  end
+
+  describe "#write" do
+    class StubWriter
+      def initialize(t); @t = t; end
+      def write; @t.write "foo"; end
+      def add_tasks(t); end
+    end
+
+    it "should write to tempfile only" do
+      storage = FileTaskStorage.new("f", anything, StubWriter)
+      tempfile = mock
+      storage.stub(:tempfile => tempfile)
+      tempfile.should_receive(:write).with("foo")
+      tempfile.should_receive(:close)
+      storage.write(anything)
+    end
+
+    it "should close tempfile if error occured" do
+      class Writer
+        def write
+          raise
+        end
+      end
+
+      tempfile = mock
+      storage = FileTaskStorage.new("f", Class, Writer)
+      storage.stub(:tempfile => tempfile)
+      tempfile.should_receive(:close)
+      storage.write([]) rescue nil #nothing
+    end
+  end
+
+  after(:each) do
+    FileUtils.rm("f") if File.exists?("f")
+  end
+end