graffle 0.1.8 → 0.1.9

data/test/abstract-graphic-tests.rb

@@ -53,4 +53,52 @@ class TestAbstractGraphics < Test::Unit::TestCase
     assert_false(equal_line.before?(graphic))
     assert_false(graphic.before?(equal_line))
   end
+  
+   rtf = %Q{
+        | {\rtf1\mac\ansicpg10000\cocoartf824\cocoasubrtf420
+        | {\fonttbl\f0\fswiss\fcharset77 Helvetica;}
+        | {\colortbl;\red255\green255\blue255;}
+        | \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural\pardirnatural
+        |
+        | \f0\fs24 \cf0 line\
+        | label\
+        | note}}.trim('|')
+  
+  
+  def test_abstract_graphics_can_be_built_with_notes
+    graphic = abstract_graphic {
+      with_notes "hi"
+    }
+    
+    assert_equal("hi", graphic['Notes'])
+    assert_equal("hi", graphic.notes)
+    
+  end
+  
+  
+  def test_abstract_graphics_do_not_have_to_have_notes
+    assert_false(abstract_graphic.has_notes?)
+  end
+  
+  def test_for_some_purposes_its_convenient_to_have_null_notes
+    assert_equal([], abstract_graphic.notes.as_lines)
+  end
+  
+  
+  def test_abstract_graphics_stereotype_their_notes
+    s = sheet {
+      with shaped_graphic { 
+        graffle_id_is 333 
+        with_note "foo"
+      }
+      with line_graphic { graffle_id_is 44 } # Check that this doesn't blow up
+    }
+    
+    # buid correct structure, but without anything stereotyped.
+    s = Plist.parse_xml(s.to_plist)
+    Sheet.takes_on(s)
+    
+    assert_true(s.find_by_id(333).note.behaves_like?(Graffle::Note))
+  end
+  
 end

data/test/document-tests.rb

@@ -74,13 +74,13 @@ class TestCaseGraffleDocumentParsing < Test::Unit::TestCase
             }.to_plist
 
   def test_parsed_file_behaves_like_whole_graffle_doc
-    graffle = Graffle.parse(MultiSheetFormat)
+    graffle = Graffle.parse_xml(MultiSheetFormat)
     assert_true(graffle.behaves_like?(Graffle::Document))
   end
   
   
   def test_can_fetch_components_from_plist
-    graffle = Graffle.parse(MultiSheetFormat)
+    graffle = Graffle.parse_xml(MultiSheetFormat)
     assert_equal(2, graffle.sheets.length)
     assert_equal('1', graffle.sheets[0]['SheetTitle']);
     assert_true(graffle.sheets[0].behaves_like?(Graffle::Sheet))
@@ -98,7 +98,7 @@ class TestCaseGraffleDocumentParsing < Test::Unit::TestCase
                       }.to_plist
   
   def test_some_graffle_documents_do_not_have_an_explicit_sheet
-    graffle = Graffle.parse(ImplicitSheetFormat)
+    graffle = Graffle.parse_xml(ImplicitSheetFormat)
     
     assert_equal(1, graffle.sheets.length)
     assert_true(graffle.sheets[0].behaves_like?(Graffle::Sheet))
@@ -107,10 +107,10 @@ class TestCaseGraffleDocumentParsing < Test::Unit::TestCase
   end
     
   def test_getting_first_sheet_only
-    graffle = Graffle.parse(ImplicitSheetFormat)
+    graffle = Graffle.parse_xml(ImplicitSheetFormat)
     assert_true(graffle.first_sheet.behaves_like?(Graffle::Sheet))
 
-    graffle = Graffle.parse(MultiSheetFormat)
+    graffle = Graffle.parse_xml(MultiSheetFormat)
     assert_true(graffle.first_sheet.behaves_like?(Graffle::Sheet))
   end
   

data/test/examples-tests.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-19.
+#  Copyright (c) 2007. All rights reserved.
+
+require "set-standalone-test-paths.rb" unless $started_from_rakefile
+require "test/unit"
+require 's4t-utils'
+include S4tUtils
+
+
+class TestThatExamplesWork < Test::Unit::TestCase
+  EXAMPLES_HOME = "#{PACKAGE_ROOT}/examples"
+  
+  def self.make_tests
+    Dir.chdir(EXAMPLES_HOME) do 
+      Dir["*.rb"].collect { |e| e.sub(/\.rb$/,'') }.each do | example |
+        make_one_test(example) 
+      end
+    end
+  end
+  
+  def self.make_one_test(name)
+    self.send(:define_method, test_message(name), lambda {
+      Dir.chdir(EXAMPLES_HOME) do
+      system "ruby '#{name}.rb' > '#{name}.actual' 2>&1"
+      system("diff '#{name}.expected' '#{name}.actual'")
+      assert_equal(0, $?)
+      system "rm '#{name}'.actual" if $? == 0
+    end
+    })
+  end
+    
+  
+  def self.test_message(name)
+    'test_' + name.gsub(/\s+|-|\./, '_')
+  end
+    
+  
+  make_tests
+    
+end

data/test/graphical_tests_for_rails/{graphic-interpreter-tests.rb → deprecated-graphic-interpreter-tests.rb}

@@ -11,35 +11,25 @@ require "../set-standalone-test-paths.rb" unless $started_from_rakefile
 
 require 'extensions/string'
 require 'graphical_tests_for_rails'
+require 'test/graphical_tests_for_rails/util'
 
 
 class GraphicInterpreterTest < Test::Unit::TestCase
   include Graffle::Builders
   include GraphicalTestsForRails
   
-  class CommandRecorder
-    attr_reader :record
-    def initialize
-      @record = []
-    end
-    
-    def method_missing(message, *args)
-      @record << "#{message}(" + args.collect { | a | a.inspect }.join(", ") + ')'
-    end
-  end
-  
   def two_graphics
     s = sheet {
       with line_label {  
         for_line 1
-        with_text 'produce "argument"'
+        with_content 'produce "argument"'
       }
       with line_graphic {
         graffle_id_is 1
       }
       with shaped_graphic {
         graffle_id_is 2
-        with_text "SIGNUP"
+        with_content "SIGNUP"
       }
     }
     
@@ -55,7 +45,7 @@ class GraphicInterpreterTest < Test::Unit::TestCase
   def test_interpreter_applies_strategies
     interpreter = GraphicInterpreter.new(two_graphics,
             'line labels' => ArgsFromQuotedText.new,
-            'shaped graphic text' => TextIsNameOfPage.new('assert_on_page'))
+            'shaped graphic text' => TextAsNameOfPage.new('assert_on_page'))
     assert_commands_produced(['produce("argument")', 'assert_on_page("signup")'],
                              interpreter)                
   end
@@ -72,7 +62,7 @@ class GraphicInterpreterTest < Test::Unit::TestCase
 
   def test_interpreter_annotates_test_failures_with_log
     interpreter = GraphicInterpreter.new(two_graphics,
-            'shaped graphic text' => TextIsNameOfPage.new('assert_that_fails'))
+            'shaped graphic text' => TextAsNameOfPage.new('assert_that_fails'))
     interpreter.run_against(self)
     flunk("Should be unreached.")
   rescue Test::Unit::AssertionFailedError => e
@@ -92,25 +82,25 @@ class GraphicInterpreterTest < Test::Unit::TestCase
     s = sheet {
       with line_label {  
         for_line 1
-        with_text 'label'
+        with_content 'label'
       }
       with line_graphic {
         graffle_id_is 1
       }
       with shaped_graphic {
         graffle_id_is 2
-        with_text "signup "
+        with_content "signup "
       }
       with line_label {  
         for_line 11
-        with_text 'waiting on a "friend"... '
+        with_content 'waiting on a "friend"... '
       }
       with line_graphic {
         graffle_id_is 11
       }
       with shaped_graphic {
         graffle_id_is 22
-        with_text "time passes..."
+        with_content "time passes..."
       }
     }
     
@@ -119,8 +109,8 @@ class GraphicInterpreterTest < Test::Unit::TestCase
   
   def test_ellipses_strategy_overrides_others
     interpreter = GraphicInterpreter.new(four_graphics_including_ellipses,
-            'line labels' => TextIsNameOfPage.new("line_here"),
-            'shaped graphic text' => TextIsNameOfPage.new('shape_here'),
+            'line labels' => TextAsNameOfPage.new("line_here"),
+            'shaped graphic text' => TextAsNameOfPage.new('shape_here'),
             'text...' => ArgsFromQuotedText.new)
     assert_commands_produced(['line_here("label")', 'shape_here("signup")',
                               'waiting_on_a("friend")', 'time_passes()'],

data/test/graphical_tests_for_rails/graphic-volunteer-tests.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-20.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'test/unit'
+require 's4t-utils'
+include S4tUtils
+
+require "../set-standalone-test-paths.rb" unless $started_from_rakefile
+
+require 'graphical_tests_for_rails/graphic-volunteers'
+require 'graphical_tests_for_rails/volunteer-pool'
+require 'graffle'
+
+class GraphicVolunteerTest < Test::Unit::TestCase
+  include GraphicalTestsForRails
+  include Graffle::Builders
+  
+  def setup
+    @pool = GraphicVolunteerPool.new
+  end
+
+  def test_untrained_volunteer_wants_to_handle_everything
+    assert_true(GraphicVolunteer.new('irrelevant').likes?(Object.new))
+  end
+  
+  def test_untrained_volunteer_does_not_even_try_to_extract_lines
+    assert_equal([], GraphicVolunteer.new('irrelevent').extract_lines(Object.new))
+  end
+  
+  # Trained volunteers will be fetched from the pool, then tested. 
+  
+  def test_volunteers_must_be_fetched_with_known_names
+    assert_raises(StandardError) {
+      @pool.mobilize_form_watcher('nothing')
+    }
+  end
+  
+  
+  
+  def test_some_volunteers_go_for_shaped_graphic_content
+    volunteer = @pool.mobilize_form_watcher('shaped graphic content')
+    
+    assert_false(volunteer.likes?(abstract_graphic))
+    assert_false(volunteer.likes?(shaped_graphic))
+    assert_false(volunteer.likes?(shaped_graphic { with_note "hello" }))
+    assert_true(volunteer.likes?(shaped_graphic { with_content "hello" }))
+  end
+  
+  def test_those_volunteers_extract_only_shaped_graphic_content_lines
+    volunteer = @pool.mobilize_form_watcher('shaped graphic content')
+    graphic = shaped_graphic {
+      with_content "expected"
+      with_note "not expected"
+    }
+    
+    assert_equal(["expected"], volunteer.extract_lines(graphic))
+  end
+  
+  def test_som_volunteers_go_for_line_label_content
+    # Here are the pieces of the structure that matter:
+    empty_label = good_label = no_label = nil
+    
+    s = sheet {
+      with label_without_text = line_label {
+        for_line 1
+      }
+      with label_with_fine_text = line_label { 
+        for_line 2
+        with_content "hi"
+      }
+      with empty_label = line_graphic { graffle_id_is 1 }
+      with good_label = line_graphic { graffle_id_is 2 }
+      with no_label = line_graphic { graffle_id_is 3 }
+    }
+  
+    volunteer = @pool.mobilize_form_watcher('line label content')
+    
+    assert_false(volunteer.likes?(shaped_graphic { with_content 'foo' }))
+    assert_false(volunteer.likes?(empty_label))
+    assert_false(volunteer.likes?(no_label))
+    assert_true(volunteer.likes?(good_label))
+  end
+  
+  def test_those_volunteers_extract_only_line_label_content_lines
+    volunteer = @pool.mobilize_form_watcher('line label content')
+
+    s = sheet {
+      with line_graphic {
+        graffle_id_is 1
+      }
+      
+      with line_label {
+        for_line 1
+        with_content "expected"
+        with_note "not expected"
+      }
+    }
+    
+    assert_equal(["expected"], volunteer.extract_lines(s.find_by_id(1)))
+  end
+
+
+  def test_some_volunteers_go_for_notes_attached_to_anything
+    # Here are the pieces of the structure that matter:
+    shaped_with_note = shaped_graphic { 
+      graffle_id_is 1
+      with_note "this matches"
+    }
+    shaped_without_note = shaped_graphic {
+      graffle_id_is 2
+      with_content "this does not"
+    }
+    line_graphic_with_nothing = line_graphic
+    line_graphic_with_only_label_text = line_graphic {
+      # label added below.
+      graffle_id_is 999
+    }
+    line_graphic_with_note = line_graphic {
+      # label added below
+      graffle_id_is 888
+    }    
+    
+    s = sheet {
+      with shaped_with_note
+      with shaped_without_note
+      with line_graphic_with_nothing
+      with line_graphic_with_only_label_text
+      with line_graphic_with_note
+
+      with line_label { 
+        for_line line_graphic_with_only_label_text.graffle_id
+        with_content "unmatching line label"
+      }
+      with line_label {
+        for_line line_graphic_with_note.graffle_id
+        with_note "matching line label - has note"
+      }
+    }
+
+    volunteer = @pool.mobilize_form_watcher('note')
+    assert_true(volunteer.likes?(shaped_with_note))
+    assert_false(volunteer.likes?(shaped_without_note))
+    assert_false(volunteer.likes?(line_graphic_with_nothing))
+    assert_false(volunteer.likes?(line_graphic_with_only_label_text))
+    assert_true(volunteer.likes?(line_graphic_with_note))
+  end
+
+  def test_those_volunteers_extract_only_note_lines
+    shaped_with_note = shaped_graphic { with_note "expected" }
+    line_with_label_note = line_graphic { graffle_id_is 1 } # label added later
+    line_with_own_note = line_graphic { with_note "expected"}
+    line_with_both = line_graphic { 
+      graffle_id = 999
+      with_note "expected"
+    } 
+    
+    s = sheet {
+      with shaped_with_note
+      with line_with_label_note
+      with line_with_own_note
+      with line_with_both
+      with line_label {
+        for_line line_with_label_note.graffle_id
+        with_note "expected"
+      }
+      with line_label {
+        for_line line_with_both.graffle_id
+        with_note "NOT expected - line note takes precedence"
+      }
+    }
+
+    volunteer = @pool.mobilize_form_watcher('note')
+
+    assert_equal(["expected"], volunteer.extract_lines(shaped_with_note))
+    assert_equal(["expected"], volunteer.extract_lines(line_with_label_note))
+    assert_equal(["expected"], volunteer.extract_lines(line_with_own_note))
+    assert_equal(["expected"], volunteer.extract_lines(line_with_both))
+  end
+
+  #
+  # Content volunteers look at lines of text, not graphics.
+  # They don't extract lines, so that's not tested.
+  #
+  
+  def test_some_content_volunteers_go_for_text_with_ellipses
+    volunteer = @pool.mobilize_content_watcher('text...')
+    
+    assert_true(volunteer.likes?(["foo..."]))
+    assert_true(volunteer.likes?(["foo.."]))  # allow typos
+    assert_true(volunteer.likes?(["foo...."]))
+    assert_true(volunteer.likes?(["foo....  "]))
+    assert_false(volunteer.likes?(["foo...b"]))
+  end
+  
+  def test_some_content_volunteers_go_for_text_to_be_ignored
+    volunteer = @pool.mobilize_content_watcher('ignore')
+    
+    assert_true(volunteer.likes?(["ignore"]))
+    assert_true(volunteer.likes?([" ignore  "]))
+    assert_false(volunteer.likes?(["something else"]))
+    assert_true(volunteer.likes?(["something else", "ignore"]))
+  end
+  
+  def test_content_volunteers_are_chained_after_form_volunteers
+    graphic_volunteer = @pool.mobilize_form_watcher('note')
+    text_volunteer = @pool.mobilize_content_watcher('text...')
+    
+    g = shaped_graphic { with_note "no ellipses" }
+    assert_true(graphic_volunteer.likes?(g))
+    graphic_volunteer.next = text_volunteer
+    assert_false(graphic_volunteer.likes?(g))
+    
+    assert_true(graphic_volunteer.likes?(shaped_graphic{ with_note "..."}))
+  end
+  
+end