Pull Summary out, update Filter, fix tests

Author: mtodd

lib/task_list.rb

@@ -1,3 +1,4 @@
+require 'task_list/summary'
 require 'task_list/version'
 
 # encoding: utf-8
@@ -28,26 +29,4 @@ def complete?
       checkbox_text == Complete
     end
   end
-
-  class Summary < Struct.new(:items)
-    # Public: returns true if there are any TaskList::Item objects.
-    def items?
-      item_count > 0
-    end
-
-    # Public: returns the number of TaskList::Item objects.
-    def item_count
-      items.size
-    end
-
-    # Public: returns the number of complete TaskList::Item objects.
-    def complete_count
-      items.select{ |i| i.complete? }.size
-    end
-
-    # Public: returns the number of incomplete TaskList::Item objects.
-    def incomplete_count
-      items.select{ |i| !i.complete? }.size
-    end
-  end
 end

lib/task_list/filter.rb

@@ -23,8 +23,30 @@ def self.filter(*args)
   # - [ ] incomplete
   # - [x] complete
   # ```
+  #
+  # Results
+  # -------
+  #
+  # The following keys are written to the result hash:
+  #   :task_list_items - An array of TaskList::Item objects.
   class Filter < HTML::Pipeline::Filter
 
+    Incomplete  = "[ ]".freeze
+    Complete    = "[x]".freeze
+
+    # Pattern used to identify all task list items.
+    # Useful when you need iterate over all items.
+    ItemPattern = /
+      ^
+      (?:\s*[-+*]|(?:\d+\.))? # optional list prefix
+      \s*                     # optional whitespace prefix
+      (                       # checkbox
+        #{Regexp.escape(Complete)}|
+        #{Regexp.escape(Incomplete)}
+      )
+      (?=\s)                  # followed by whitespace
+    /x
+
     ListSelector = [
       # select UL/OL
       ".//li[starts-with(text(),'[ ]')]/..",
@@ -52,6 +74,14 @@ def next_index
       @index += 1
     end
 
+    # List of `TaskList::Item` objects that were recognized in the document.
+    # This is available in the result hash as `:task_list_items`.
+    #
+    # Returns an Array of TaskList::Item objects.
+    def task_list_items
+      result[:task_list_items] ||= []
+    end
+
     # Renders the item checkbox in a span including the item index and state.
     #
     # Returns an HTML-safe String.
@@ -77,7 +107,7 @@ def render_item_checkbox(item)
     def render_task_list_item(item)
       Nokogiri::HTML.fragment <<-html, 'utf-8'
         <label>#{
-          item.source.sub(TaskList::ItemPattern, render_item_checkbox(item))
+          item.source.sub(ItemPattern, render_item_checkbox(item))
         }</label>
       html
     end
@@ -106,8 +136,10 @@ def filter_list(node)
           else
             [li, li.inner_html]
           end
-        if match = TaskList.item?(inner)
+        if match = (inner.chomp =~ ItemPattern && $1)
           item = TaskList::Item.new(next_index, match, inner)
+          task_list_items << item
+
           add_css_class(li, 'task-list-item')
           outer.inner_html = render_task_list_item(item)
         end

lib/task_list/summary.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'html/pipeline'
+require 'task_list'
+
+class TaskList
+  # Provides a summary of provided TaskList `items`.
+  #
+  # `items` is an Array of TaskList::Item objects.
+  class Summary < Struct.new(:items)
+    # Public: returns true if there are any TaskList::Item objects.
+    def items?
+      item_count > 0
+    end
+
+    # Public: returns the number of TaskList::Item objects.
+    def item_count
+      items.size
+    end
+
+    # Public: returns the number of complete TaskList::Item objects.
+    def complete_count
+      items.select{ |i| i.complete? }.size
+    end
+
+    # Public: returns the number of incomplete TaskList::Item objects.
+    def incomplete_count
+      items.select{ |i| !i.complete? }.size
+    end
+  end
+end

test/task_list/summary_test.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+require File.expand_path('../../test_helper', __FILE__)
+require 'task_list/summary'
+
+class TaskList::SummaryTest < Test::Unit::TestCase
+  def setup
+    @complete   = make_item 1, "[x]", "complete"
+    @incomplete = make_item 2, "[ ]", "incomplete"
+    @items = [@complete, @incomplete]
+    @summary = make_summary @items
+  end
+
+  def test_no_items
+    summary = make_summary []
+    assert !summary.items?, "no task list items are expected"
+  end
+
+  def test_items
+    assert @summary.items?, "task list items are expected"
+    assert_equal 2, @summary.item_count
+  end
+
+  def test_complete_count
+    assert_equal 1, @summary.complete_count
+  end
+
+  def test_incomplete_count
+    assert_equal 1, @summary.incomplete_count
+  end
+
+  protected
+
+  def make_item(index = 1, checkbox_text = "[ ]", source = "an item!")
+    TaskList::Item.new(index, checkbox_text, source)
+  end
+
+  def make_summary(items)
+    TaskList::Summary.new(items)
+  end
+end

test/task_list_test.rb

@@ -1,103 +1,21 @@
 # encoding: utf-8
 require File.expand_path('../test_helper', __FILE__)
 require 'task_list'
+require 'task_list/filter'
 
 class TaskListTest < Test::Unit::TestCase
-
-  def test_updates_task_list_item_by_index
-    text = <<-md
-- [ ] index 1, incomplete
-- [x] index 2, complete
-    md
-
-    assert_match "- [x] index 1, incomplete", update(text, 1, true).source
-    assert_match "- [ ] index 2, complete", update(text, 2, false).source
-  end
-
-  def test_updates_task_lists_in_numbered_lists
-    text = <<-md
-1.  [ ] index 1, incomplete
-14. [x] index 2, complete
-    md
-
-    assert_match "1.  [x] index 1, incomplete", update(text, 1, true).source
-    assert_match "14. [ ] index 2, complete", update(text, 2, false).source
-  end
-
-  def test_updates_ignore_task_lists_in_code_fences
-    text = <<-md
-```
-- [ ] should not be indexed
-- [x] nor this
-```
-
-- [ ] index 1, incomplete
-- [x] index 2, complete
-    md
-
-    assert_match "- [x] index 1, incomplete", update(text, 1, true).source
-    assert_match "- [ ] index 2, complete", update(text, 2, false).source
-  end
-
-  def test_updates_ignores_items_in_paras
-    text = <<-md
-here's a paragraph:
-
-[ ] should not be indexed
-[x] nor this
-
-- [ ] index 1, incomplete
-- [x] index 2, complete
-    md
-
-    assert_match "- [x] index 1, incomplete", update(text, 1, true).source
-    assert_match "- [ ] index 2, complete", update(text, 2, false).source
-  end
-
-  def test_update_cleans_carriage_returns_for_matches
-    text = <<-md
-``` markdown\r
-- [ ] foo\r
-```\r
-\r
-- [ ] index 1, incomplete\r
-- [x] index 2, complete\r
-    md
-
-    assert_match "- [x] index 1, incomplete", update(text, 1, true).source
-    assert_match "- [ ] index 2, complete", update(text, 2, false).source
-  end
-
-  def test_task_list_for_nil_body
-    assert task_list(nil).items.empty?, "no task list items are expected"
+  class Record < Struct.new(:body)
+    def task_list_items
+      []
+    end
   end
 
-  def test_task_list_summary
-    summary = task_list("").summary
-    assert !summary.items?, "no task list items are expected"
-
-    text = <<-md
-- [ ] one
-- [x] two
-
-```
-- [ ] don't count me yo
-- [x] nor me
-```
-    md
-
-    summary = task_list(text).summary
-    assert summary.items?, "task list items are expected"
-    assert_equal 2, summary.item_count
-    assert_equal 1, summary.complete_count
-    assert_equal 1, summary.incomplete_count
+  def test_has_summary
+    assert summary = task_list("- [ ] one").summary, "summary expected"
+    assert_kind_of TaskList::Summary, summary
   end
 
   def task_list(text)
-    TaskList.new(text)
-  end
-
-  def update(text, index, checked)
-    task_list(text).update(index, checked)
+    TaskList.new(Record.new(text))
   end
 end