graffle 0.1.9 → 0.2.0

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

@@ -1,218 +0,0 @@
-#!/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  

data/test/graphical_tests_for_rails/picture-applier-tests.rb

@@ -1,215 +0,0 @@
-#!/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 'extensions/string'
-require 'test/graphical_tests_for_rails/util'
-require 'graffle'
-require 'graphical_tests_for_rails/picture-appliers'
-
-class PictureApplierTest < Test::Unit::TestCase
-  include Graffle
-  include Graffle::Builders
-  include GraphicalTestsForRails
-  include GraphicalTestsForRails::TextAppliers
-
-  def setup
-    @sheet = sheet { 
-      with shaped_graphic { 
-        graffle_id_is 1
-          with_content 'shaped graphic text...' 
-        }
-      with line_label {  
-        for_line 22
-        with_content 'line label text...'
-      }
-      with line_graphic {
-        graffle_id_is 22
-      }
-      with shaped_graphic {  # no text
-        graffle_id_is 333
-      }
-      with line_graphic {    # no label 
-        graffle_id_is 4444
-      }
-    }
-  end
-  
-  def shaped_graphic_with_content; @sheet.find_by_id(1); end
-  def shaped_graphic_without_text; @sheet.find_by_id(333); end
-  def line_graphic_with_label; @sheet.find_by_id(22); end
-  def line_graphic_without_label; @sheet.find_by_id(4444); end
-    
-
-  def test_empty_applier_produces_eager_but_useless_volunteer
-    @applier = PictureApplier.new
-    g = shaped_graphic { with_content 'foo' }
-    assert_equal(EagerButUselessVolunteer, @applier.find_volunteer_for(g).class)
-    # Or, as shorthand:
-    assert_eager_but_useless_volunteer_for(g)
-  end
-
-  def assert_eager_but_useless_volunteer_for(graphic)
-    assert_equal(EagerButUselessVolunteer, @applier.find_volunteer_for(graphic).class)
-  end
-  
-  def assert_trained_volunteer_for(graphic)
-    assert_not_equal(EagerButUselessVolunteer, @applier.find_volunteer_for(graphic).class)
-  end
-  
-  def test_useless_volunteer_does_nothing
-    # ... so we can just test for it rather than having it do something.  
-    @applier = PictureApplier.new
-    g = shaped_graphic { with_note 'foo' }
-    @applier.apply([g], "will blow up if used")
-  end
-  
-
-  # Some examples of how a PictureApplier can use the Volunteer
-  # mechanism to prepare volunteers trained for certain kinds
-  # of graphics.
-  def test_can_recruit_trained_volunteers_for_shaped_graphic_contents
-    @applier = PictureApplier.new {
-      given('shaped graphic content')   # ... chained methods go here
-    }
-    
-    assert_trained_volunteer_for(shaped_graphic_with_content)
-    assert_eager_but_useless_volunteer_for(shaped_graphic_without_text)
-    assert_eager_but_useless_volunteer_for(line_graphic_with_label)
-  end
-  
-  def test_can_recruit_trained_volunteers_for_line_graphic_labels
-    @applier = PictureApplier.new {
-      given('line label content')   # ... chained methods go here
-    }
-    
-    assert_trained_volunteer_for(line_graphic_with_label)
-    assert_eager_but_useless_volunteer_for(line_graphic_without_label)
-    assert_eager_but_useless_volunteer_for(shaped_graphic_with_content)
-  end
-  
-  def test_there_is_a_fixed_set_of_graphically_oriented_volunteers 
-    assert_raises(StandardError) {
-      PictureApplier.new { given 'oopsla' }
-    }
-  end
-  
-  
-  # Examples of using the 'matching' clause to augment a 
-  # graphically-oriented volunteer with a textually-oriented one.
-  
-  def test_can_augment_a_volunteer_to_look_for_ellipses
-    @applier = PictureApplier.new {
-      given('shaped graphic content').matching('text...')   # ... chained methods go here
-    }
-    
-    assert_trained_volunteer_for(shaped_graphic { with_content "blah..." })
-    assert_eager_but_useless_volunteer_for(shaped_graphic { with_content "blah" })
-    assert_eager_but_useless_volunteer_for(shaped_graphic)
-    assert_eager_but_useless_volunteer_for(line_graphic_with_label)
-  end
-  
-  def test_there_is_a_fixed_set_of_textually_oriented_volunteers 
-    ok_so_far = PictureApplier.new { given 'shaped graphic content' }
-    assert_raises(StandardError) {
-      ok_so_far.matching('something never defined')
-    }
-  end
-  
-  # An example of how it's all put together to send messages to targets.
-  
-  class Echoer < AbstractTextApplier
-    def message_and_args_from(string)
-      [:echo, string]
-    end
-  end
-  
-  def test_application_of_matches
-    @applier = PictureApplier.new {
-      given('note').matching('text...').skip
-      given('note').use(Echoer.new)
-    }
-    
-    s = sheet {
-      with shaped_graphic { with_notes 'hello world' }
-      with line_graphic
-      with shaped_graphic { with_notes "waiting..."}
-      with line_graphic { with_notes "goodbye world" }
-    }
-    
-    target = CommandRecorder.new
-    @applier.apply(s.graphics, target)    
-    assert_equal(['echo("hello world")', 'echo("goodbye world")'], 
-                 target.record)
-  end
-  
-  
-  class ThriceThenDie
-    include Test::Unit::Assertions
-    
-    def initialize
-      @count = 0
-    end
-    
-    def echo(value)
-      @count += 1 
-      assert_equal("right", "wrong") if @count >= 4
-    end
-    
-  end
-
-  def four_counting_shaped_graphics
-    sheet {
-      with shaped_graphic { with_content "first" }
-      with shaped_graphic { with_content "second" }
-      with shaped_graphic { with_content "third" }
-      with shaped_graphic { with_content "yikes!"}
-    }.graphics
-  end
-  
-  def four_graphic_contents
-    four_counting_shaped_graphics.collect { |g| g.content.as_plain_text }
-  end
-  
-  def assert_thrice_then_die_log(exc, expected_echoed)
-    assert_match(/right.*expected.*was.*wrong/m, exc.message)
-    expected = expected_echoed.collect do |w|
-      "echo\\(" + w.inspect + "\\)"
-    end.join('.*')
-    assert_match(/#{expected}/m, exc.message)
-  end
-  
-  def test_logging_prints_list_of_calls_into_target
-    @applier = PictureApplier.new {
-      given('shaped graphic content').use(Echoer.new)
-    }
-    begin
-      @applier.apply(four_counting_shaped_graphics, ThriceThenDie.new)
-    rescue Test::Unit::AssertionFailedError => e 
-      assert_thrice_then_die_log(e, four_graphic_contents)
-    end
-  end
-  
-  def test_log_can_be_injected
-    def test_logging_prints_list_of_calls_into_target
-      @applier = PictureApplier.new {
-        given('shaped graphic content').use(Echoer.new)
-      }
-      begin
-        @applier.apply(four_counting_shaped_graphics, 
-                       ThriceThenDie.new,
-                       ['echo("prior value of log")'])
-      rescue Test::Unit::AssertionFailedError => e 
-        assert_thrice_then_die_log(e, ["prior value of log"] + four_graphic_contents)
-      end
-    end
-  end
-  
-end

data/test/graphical_tests_for_rails/text-applier-tests.rb

@@ -1,111 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Brian Marick on 2007-07-11.
-#  Copyright (c) 2007. All rights reserved.
-
-require "../set-standalone-test-paths.rb" unless $started_from_rakefile
-
-require 'test/unit'
-require 's4t-utils'
-include S4tUtils
-
-require 'extensions/string'
-require 'graphical_tests_for_rails'
-
-
-class TestProductionOfMessages < Test::Unit::TestCase
-  include GraphicalTestsForRails
-  
-  def assert_translation(expected, original)
-    actual = @interpreter.message_and_args_from(original)
-    assert_equal(expected, actual)
-  end
-  
-  def test_messages_whose_arguments_come_from_quoted_text
-    @interpreter = ArgsFromQuotedText.new
-
-    assert_translation(['token'], "token")
-    assert_translation(['underscore_separated_tokens'],
-                       'underscore separated tokens'
-    )
-    assert_translation(['whitespace_is_handled_intelligently'],
-                       " whitespace\tis   handled intelligently  "
-    )
-    assert_translation(['here_is_an', 'argument'],
-                       'here is an "argument"'
-    )
-    assert_translation(['single_spaces_are_args', 'too '],
-                       " single spaces are args 'too ' "
-    )
-    assert_translation(['multiple', 'arguments', "work"],
-                       %q{multiple 'arguments' "work"}
-    )
-    assert_translation(['only_the', 'prefix', "command"],
-                       %q{only the 'prefix' is included in the 'command'}
-    )
-    
-    assert_translation(['arguments_can', 'be', 'comma', "separated"],
-                       %q{arguments can 'be', 'comma', and 'separated'}
-    )
-    
-    assert_translation(['stuff_after_the', 'last', 'argument'],
-                       %q{stuff after the 'last' 'argument' is ignored.}
-    )
-    
-    assert_translation(['even_if_it_is_just', 'a period'],
-                       %q{even if it is just 'a period'.}
-    )
-    
-    assert_translation(['the_method_ignores_punctuation'],
-                       %q{the method (ignores) punctuation.}
-    )
-    
-    assert_translation(['except_that_dashes_become_underscore'],
-                       %q{except that dashes become-underscore}
-    )
-    
-    assert_translation(["its_possible_to_have_quotes_within_words"],
-                       %q{it's possible to have quotes within words}
-    )
-    
-    assert_translation(["while_a_messages_quotes_are_stripped", "an argument's are retained"],
-                       %q{while a message's quotes are stripped, "an argument's are retained"}
-    )
-    
-    assert_translation(["capitals_are_lowercased_throughout"],
-                       %q{Capitals are lowercased THROUGHOUT})
-  end
-  
-  def test_messages_created_from_prefix_name_and_quoted_args
-    @interpreter = PrefixNameAndArgsFromQuotedText.new
-    
-    assert_translation(["runs", "nathan"],
-                       %q{Nathan runs})
-
-    assert_translation(["runs_to", "nathan", "Tacoma"],
-                       %q{Nathan runs to "Tacoma"})  
-
-    assert_raises_with_matching_message(StandardError, /'runs' cannot be split into a name and an action./) {
-       @interpreter.message_and_args_from('runs')
-    }
-  end
-
-  def test_messages_created_from_page_names
-    @interpreter = TextAsNameOfPage.new('assert_on_page')
-    assert_translation(['assert_on_page', "markup"],
-                       "MARKUP")
-                       
-    assert_translation(['assert_on_page', "outside-spaces"],
-                        " outside-spaces ")
-
-    # TODO: don't know what makes sense for interior spaces or 
-    # non-\w characters.
-                       
-  end
-
-
-  def test_ineffectual_interpreters_produce_messages_that_do_nothing
-    @interpreter = TextApplierThatDoesNothing.new
-    assert_translation([:object_id], "MARKUP")
-  end
-end