medo 0.1.1 → 0.1.3

data/lib/medo/commands/show.rb

@@ -2,17 +2,16 @@ require 'medo/text_task_writer'
 
 desc "Show particular note"
 command [:show, :cat] do |c|
-  c.action do |global_options, options, args|
-    tasks = storage.read
+  c.desc "Number of task to show"
+  c.flag [:n, :number]
+  c.default_value 1
 
+  c.action do |global_options, options, args|
     include TextTaskWriter::Decorators
-    writer = NumbersDecorator.decorate(TextTaskWriter.new)
-
-    #waiting for fix of https://github.com/davetron5000/gli/pull/90
-    ColorsDecorator.decorate(writer) unless global_options[:"no-color"] == false
-
-    task, number = choose_task(args, tasks)
-    writer.add_tasks([task])
+    writer = TextTaskWriter.new
+    colorize { ColorsDecorator.decorate(writer) }
+    task, number = choose_task
+    writer.add_task(task)
     writer.write
   end
 end

data/lib/medo/notes.rb

@@ -0,0 +1,39 @@
+require 'forwardable'
+
+module Medo
+  class Notes
+    include Comparable
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@notes, :<=>, :empty?
+
+    def initialize(*args)
+      @notes = args.flatten.map { |n| n.to_s.strip }.reject(&:empty?).join("\n")
+    end
+
+    def <<(other)
+      @notes << "\n#{other}"
+      @notes.lstrip!
+    end
+
+    def each
+      @notes.each_line { |line| yield line.chomp }
+    end
+
+    def ==(other)
+      return true if other.equal? self
+      other.to_s == @notes
+    end
+
+    def initialize_copy(source)
+      super
+      @notes = @notes.dup
+    end
+
+    def to_s
+      @notes
+    end
+  end
+end
+

data/lib/medo/task.rb

@@ -1,3 +1,5 @@
+require 'medo/notes'
+
 module Medo
   class Task
     include Comparable
@@ -20,11 +22,10 @@ module Medo
     self.clock = Time
 
     def initialize(description, options = {})
-      @description  = description.to_s.strip
-      raise ArgumentError, "No description given!" if @description.empty?
+      self.description = description
       @created_at   = clock.now
       @completed_at = nil
-      @notes        = parse_notes(options["notes"] || options[:notes])
+      self.notes    = options["notes"] || options[:notes]
     end
 
     def <=>(other)
@@ -40,11 +41,44 @@ module Medo
       end
     end
 
+    def ==(other)
+      return true if other.equal? self
+      return false unless other.kind_of?(self.class)
+      self.description    == other.description &&
+        self.created_at   == other.created_at &&
+        self.done?        == other.done? &&
+        self.completed_at == other.completed_at &&
+        self.notes        == other.notes
+    end
+
+    def initialize_copy(source)
+      super
+      @description  = @description.dup
+      @created_at   = @created_at.dup
+      @completed_at = @completed_at.dup if @completed_at
+      @notes        = @notes.dup
+    end
+
+    def description=(desc)
+      description = desc.to_s.strip
+      raise ArgumentError, "No description given!" if description.empty?
+      @description  = description
+    end
+
+    def notes=(*args)
+      @notes = Notes.new(*args)
+    end
+
     def done
       @completed_at = clock.now
       @done         = true
     end
 
+    def reset
+      @completed_at = nil
+      @done         = false
+    end
+
     def done?
       !!@done
     end
@@ -54,10 +88,6 @@ module Medo
     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

@@ -1,3 +1,5 @@
+require 'medo/task'
+
 module Medo
   class TaskReader
     def read

data/lib/medo/task_writer.rb

@@ -1,3 +1,5 @@
+require 'medo/task'
+
 module Medo
   class TaskWriter
     def initialize

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

@@ -6,24 +6,34 @@ module Medo
       module NumbersDecorator
         extend Support::Decorator
 
+        after_decorate do |options|
+          @num_options = options
+        end
+
         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)
+            TaskNumbers.decorate(t, i + 1, max_tasks_count, @num_options)
           end
         end
 
         module TaskNumbers
           extend Support::Decorator
 
-          after_decorate do |number, total|
+          after_decorate do |number, total, options|
             @number        = number
             @number_length = total.to_s.size
+            @num_options   = options || {}
           end
 
           def number
             format = "%-#{@number_length + 1}s"
-            format % (@task.done? ? "" : "#@number.")
+            format % (number? ? "" : "#@number.")
+          end
+
+          def number?
+            @num_options[:done] && @task.done? ||
+              @num_options[:pending] && !@task.done?
           end
 
           def done

data/spec/lib/cli_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'medo/cli'
+
+describe "CLI" do
+end
+

data/spec/lib/cli_support_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'medo/cli_support'
+
+describe "CLISupport" do
+  class CLISupportContext
+    include Medo::CLISupport
+
+    def storage
+      @storage ||= RSpec::Mocks::Mock.new(:Storage)
+    end
+
+    def global_options
+      @global_options ||= {}
+    end
+  end
+  # def load_commands
+  # def choose_task(select_options = {})
+  # def get_input
+
+  let(:tasks) { ["foo", "bar"] }
+
+  before(:each) do
+    @context = CLISupportContext.new
+    @context.storage.stub(:read => tasks)
+  end
+
+  describe "#tasks" do
+    it "should read and memoize tasks" do
+      @context.tasks.should == tasks
+      @context.tasks.object_id.should == tasks.object_id
+    end
+  end
+
+  describe "#tasks_changed" do
+    it "should react to changess in tasks collection" do
+      @context.tasks
+      expect do
+        tasks.last.upcase!
+      end.to change { @context.tasks_changed? }
+    end
+  end
+
+  describe "#colorize" do
+    let(:touch) { mock }
+
+    it "should yield if color mode enabled" do
+      @context.global_options[:"no-color"] = true #color
+      touch.should_receive(:touched)
+      @context.colorize { touch.touched }
+    end
+
+    it "should not yield if color mode disabled" do
+      @context.global_options[:"no-color"] = false #no color
+      touch.should_not_receive(:touched)
+      @context.colorize { touch.touched }
+    end
+  end
+
+  describe "#committing tasks" do
+    it "should write and commit tasks if changed" do
+      @context.storage.should_receive(:write).with(tasks)
+      @context.storage.should_receive(:commit)
+      @context.tasks
+      @context.committing_tasks do
+        tasks.last.upcase!
+      end
+    end
+
+    it "should not write tasks if not changed" do
+      @context.storage.should_not_receive(:write)
+      @context.storage.should_not_receive(:commit)
+      @context.tasks
+      @context.committing_tasks { }
+    end
+  end
+
+end
+
+

data/spec/lib/json_task_reader_spec.rb

@@ -3,24 +3,24 @@ require 'support/task_stubs_spec_helper'
 require 'medo/json_task_reader'
 require 'stringio'
 
-include Medo
-
-describe JsonTaskReader do
+module Medo
   unless defined? Task
     class Task; end
   end
 
-  include TaskStubsSpecHelper
+  describe JsonTaskReader do
+    include TaskStubsSpecHelper
 
-  it "should read tasks" do
-    fake_input = StringIO.new '[{"done":false,"description":"Buy Milk","created_at":"2012-01-05 12:04:00",'\
-        '"completed_at":null,"notes":[]},{"done":true,"description":"Buy Butter","created_at":"2012-01-05 15:30:00",'\
-        '"completed_at":"2012-01-05 16:30:00","notes":["Note 1","Note 2"]}]'
+    it "should read tasks" do
+      fake_input = StringIO.new '[{"done":false,"description":"Buy Milk","created_at":"2012-01-05 12:04:00",'\
+          '"completed_at":null,"notes":""},{"done":true,"description":"Buy Butter","created_at":"2012-01-05 15:30:00",'\
+          '"completed_at":"2012-01-05 16:30:00","notes":"Note 1\nNote 2"}]'
 
-    Task.should_receive(:from_attributes).with(pending_task_attributes).and_return(1)
-    Task.should_receive(:from_attributes).with(completed_task_attributes).and_return(2)
+      Task.should_receive(:from_attributes).with(pending_task_attributes).and_return(1)
+      Task.should_receive(:from_attributes).with(completed_task_attributes).and_return(2)
 
-    JsonTaskReader.new(fake_input).read.should == [1, 2]
-  end
+      JsonTaskReader.new(fake_input).read.should == [1, 2]
+    end
+  end 
 end
 

data/spec/lib/notes_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'medo/notes'
+
+module Medo
+  describe Notes do
+    it "should be create from various arguments" do
+      Notes.new(["1", "2"]).should == "1\n2"
+      Notes.new(0).should          == "0"
+      Notes.new([0, nil]).should   == "0"
+      Notes.new("note").should     == "note"
+      Notes.new.should             == ""
+    end
+
+    it "should allow appending notes" do
+      notes = Notes.new
+      notes << "My Note"
+      notes.should == "My Note"
+      notes << "FooBar"
+      notes.should == "My Note\nFooBar"
+    end
+
+    it "should be coerced to string" do
+      Notes.new(["foo", "bar"]).to_s.should == "foo\nbar"
+    end
+
+    it "should respond to #empty?" do
+      Notes.new.should be_empty
+      Notes.new("foo").should_not be_empty
+    end
+
+    it "should be enumerable" do
+      expect { |b| Notes.new("foo\nbar").each(&b) }.to yield_successive_args("foo", "bar")
+    end
+
+    it "should test for equality" do
+      Notes.new("foo").should == Notes.new("foo")
+      Notes.new("foo").should_not == Notes.new("foo\nbar")
+    end
+
+    it "should be duplicable" do
+      n1 = Notes.new("foo")
+      n2 = n1.dup
+      n1 << "bar"
+      n2.should == "foo"
+    end
+  end
+end
+

data/spec/lib/task_spec.rb

@@ -6,15 +6,11 @@ describe Medo::Task do
     Medo::Task.new("description").description.should == "description"
   end
 
-  it "should require description to be set" do
-    proc { Medo::Task.new("")  }.should raise_error(ArgumentError)
-    proc { Medo::Task.new(" ") }.should raise_error(ArgumentError)
-  end
-
+  Notes = Class.new unless defined? Notes
   it "should allow notes to be set upon creation" do
-    Medo::Task.new("description", :notes => ["1", "2"]).notes.should ==  ["1", "2"]
-    Medo::Task.new("description", :notes => 0).notes.should          ==  ["0"]
-    Medo::Task.new("description", :notes => [0, nil]).notes.should   ==  ["0"]
+    args = anything
+    Notes.should_receive(:new).with(args)
+    Medo::Task.new("description", :notes => ["1", "2"])
   end
 
   it "should assign creation time upon instantiation" do
@@ -24,12 +20,6 @@ describe Medo::Task do
     end
   end
 
-  it "should allow assigning notes to the task" do
-    task = Medo::Task.new("description")
-    task.notes << "My Note"
-    task.notes.should include("My Note")
-  end
-
   it "should not allow comparison with shit" do
     task1 = Medo::Task.new("asdfsd")
     proc { task1 <=> :foo }.should raise_error(ArgumentError)
@@ -68,17 +58,24 @@ describe Medo::Task do
     task.should be_done
   end
 
+  it "should reset done state if #reset called" do
+    task = Medo::Task.new("Buy milk")
+    task.done
+    task.reset
+    task.should_not be_done
+  end
+
   describe ".from_attributes" do
     it "should allow all attributes to be set from hash" do
       created_at   = Time.now
       completed_at = Time.now
       task = Medo::Task.from_attributes("description"  => "d", 
-                                        "notes"        => ["n"], 
+                                        "notes"        => "n", 
                                         "done"         => true, 
                                         "completed_at" => completed_at, 
                                         "created_at"   => created_at)
       task.description.should  ==  "d"
-      task.notes.should        ==  ["n"]
+      task.notes.should        ==  "n"
       task.completed_at.should ==  completed_at
       task.created_at.should   ==  created_at
       task.should be_done
@@ -92,6 +89,44 @@ describe Medo::Task do
     end
   end
 
+  it "should not be equal if notes differs" do
+    c = Time.now
+    t1 = Medo::Task.from_attributes("description" => "d", "created_at" => c, "notes" => "foo")
+    t2 = Medo::Task.from_attributes("description" => "d", "created_at" => c, "notes" => "foo")
+    t1.should == t2
+    t1.notes << "bar"
+    t1.should_not == t2
+  end
+
+  it "should duplicate with children" do
+    t1 = Medo::Task.new("description", "notes" => "my note")
+    t2 = t1.dup
+    t1.description.should_not equal(t2.description)
+    t1.notes.should_not equal(t2.notes)
+  end
+
+  context "#description=" do
+    let(:task) { Medo::Task.new("description") }
+
+    it "should allow settings description" do
+      task.description = "foo"
+      task.description.should == "foo"
+    end
+
+    it "should raise if description is bad" do
+      expect do
+        task.description = nil
+      end.to raise_error ArgumentError
+    end
+  end
+
+  Notes = Class.new unless defined? Notes
+  it "should create a Notes instance on #notes=" do
+    t = Medo::Task.new("foo")
+    Notes.should_receive(:new).with("bar")
+    t.notes = "bar"
+  end
+
   def using_fake_clock(fake_clock)
     Medo::Task.clock = fake_clock
     yield