graffle 0.1.9 → 0.2.0

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

@@ -0,0 +1,129 @@
+#!/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-applier'
+
+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_there_is_a_fixed_set_of_graphically_oriented_volunteers 
+    assert_raises(StandardError) {
+      PictureApplier.new { 
+        given('oopsla').skip
+      }
+    }
+  end
+  
+  
+  # An example of how it's all put together to send messages to targets.
+  
+  
+  def test_application_of_matches
+    @applier = PictureApplier.new {
+      given('note').matching('text...').skip
+      given('note').use(ArgsFromQuotedText.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(['hello_world()', 'goodbye_world()'], 
+                 target.record)
+  end
+  
+  
+  class ThriceThenDie
+    include Test::Unit::Assertions
+    
+    def initialize
+      @count = 0
+    end
+    
+    def assert_on_page(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|
+      "assert_on_page\\(" + 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(TextAsNameOfPage.new('assert_on_page'))
+    }
+    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
+  
+end

data/test/graphical_tests_for_rails/user-intention-tests.rb

@@ -0,0 +1,389 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-31.
+#  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 'graffle'
+require 'graphical_tests_for_rails/user-intention'
+require 'test/graphical_tests_for_rails/util'
+
+
+class TestUserIntention < Test::Unit::TestCase
+  include GraphicalTestsForRails
+  include TextAppliers
+  include Graffle::Builders
+  include UserIntention::Names
+  
+  def self.make_assert_foo_understood(foo)
+    class_eval %Q{def assert_#{foo}_understood(expected, input)
+                    terp = UserIntention.new
+                    terp.understand_#{foo}(input)
+                    assert_equal(expected, terp.#{foo}.value)
+                end}
+  end
+  make_assert_foo_understood('place')
+  make_assert_foo_understood('text')
+  make_assert_foo_understood('action')
+  make_assert_foo_understood('line_guard')
+
+  def setup
+    @note = UserIntention.understand("ignore note")
+    @content = UserIntention.understand("ignore content")
+    @line_note = UserIntention.understand("ignore line note")
+    @line_label_note = UserIntention.understand("ignore line label note")
+    @shaped_graphic_note = UserIntention.understand("ignore shape note")
+    @line_label_content = UserIntention.understand("ignore line label content")
+    @shaped_graphic_content = UserIntention.understand("ignore shape content")
+    
+    
+  end
+  
+  def test_user_intention_can_identify_annotation_forms
+    assert_place_understood(USER_MEANS_ANY_NOTE, "notes blah")
+    assert_place_understood(USER_MEANS_ANY_NOTE, "blah notes blah")
+    assert_place_understood(USER_MEANS_ANY_NOTE, "blah note")
+    assert_place_understood(USER_MEANS_ANY_NOTE, "blah annotation")
+    assert_place_understood(USER_MEANS_ANY_NOTE, "annotations")
+  end
+  
+  def test_user_intention_can_identify_content_forms
+    assert_place_understood(USER_MEANS_ANY_CONTENT, "contents blah")
+    assert_place_understood(USER_MEANS_ANY_CONTENT, "blah contents blah")
+    assert_place_understood(USER_MEANS_ANY_CONTENT, "blah content")
+  end
+  
+  def test_user_intention_can_understand_combined_forms
+    assert_place_understood(USER_MEANS_LINE_LABEL_CONTENT, "line label's content")
+    assert_place_understood(USER_MEANS_LINE_LABEL_NOTE, "line label note")
+    assert_place_understood(USER_MEANS_LINE_NOTE, "line with annotation")
+    assert_place_understood(USER_MEANS_SHAPED_GRAPHIC_CONTENT, "shaped graphic content")
+    assert_place_understood(USER_MEANS_SHAPED_GRAPHIC_CONTENT, "content of shape")
+    assert_place_understood(USER_MEANS_SHAPED_GRAPHIC_NOTE, "note on shape")
+  end
+  
+  def test_user_intention_requires_some_sort_of_graphic
+    assert_raises_with_matching_message(StandardError, /blah'.*does not.*refer to any graphic/) {
+      terp = UserIntention.new
+      terp.understand_place("blah blah blah")
+    }
+  end
+  
+  
+  def test_user_intention_can_understand_controlling_text
+    assert_text_understood(USER_MEANS_CONTAINS_IGNORE, "shape ignore content")
+  end  
+  
+  def test_it_is_ok_for_the_input_to_say_nothing_about_text_matching
+    assert_text_understood(nil, 'note')
+  end
+  
+  
+  
+  def test_user_intention_can_understand_actions
+    assert_action_understood(USER_MEANS_DO_NOTHING, "skip notes matching ignore")
+    assert_action_understood(USER_MEANS_ACTOR_ACTION_WITH_QUOTE_ARGS,
+                              "line labels are user actions with quoted args") 
+    assert_action_understood(USER_MEANS_ACTOR_ACTION_WITH_QUOTE_ARGS,
+                              "a note is a user action with arguments in quotes")
+    assert_action_understood(USER_MEANS_CLAIM_WITH_QUOTE_ARGS,
+                              "contents are claims with arguments in quotes")
+    assert_action_understood(USER_MEANS_PAGE_NAME,
+                             "contents name a page")
+  end
+  
+  def test_there_must_be_an_action_in_a_line
+    assert_raises_with_matching_message(StandardError, /blah'.*doesn't.*say what should happen/) {
+      terp = UserIntention.new
+      terp.understand_action("blah blah blah")
+    }
+  end
+    
+  def test_there_must_be_only_one_action_in_a_line
+    assert_raises_with_matching_message(StandardError, /conflicting instructions/) {
+      terp = UserIntention.new
+      terp.understand_action("notes that skip page and name a page")
+    }
+  end
+  
+  def test_discovery_of_line_guards
+    assert_line_guard_understood(USER_MEANS_LINE_ENDS_WITH_ELLIPSES, 
+                                 "line with ellipses")
+    assert_line_guard_understood(USER_MEANS_LINE_ENDS_WITH_ELLIPSES, 
+                                 "line containing text...")
+    assert_line_guard_understood(USER_MEANS_LINES_WITH_ONE_WORD, 
+                                 "a shape content line with one word names a page")
+    assert_line_guard_understood(USER_MEANS_LINES_WITH_ONE_WORD, 
+                                 "a shape content line with only one word names a page")
+    assert_line_guard_understood(USER_MEANS_REMAINING_LINES, 
+                                 "otherwise, a shape content line names a page" )
+    assert_line_guard_understood(USER_MEANS_REMAINING_LINES, 
+                                 "other kinds of shape content lines name a page" )
+  end
+  
+  def test_line_guards_may_be_omitted
+    assert_line_guard_understood(nil, "note")
+  end
+  
+  
+  
+  def test_intention_does_not_apply_to_naked_graphic
+    g = shaped_graphic
+    assert_false(@note.applies_to_graphic?(g))
+    assert_false(@content.applies_to_graphic?(g))
+    assert_false(@line_note.applies_to_graphic?(g))
+    assert_false(@line_label_note.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_note.applies_to_graphic?(g))
+    assert_false(@line_label_content.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_content.applies_to_graphic?(g))
+  end
+    
+  LINES = "hello!  \n\n  there!"  # Note whitespace
+  SPLIT_LINES = ["hello!", "there!"]
+
+  def test_intention_can_apply_to_shaped_graphic_with_content
+    g = shaped_graphic { with_content LINES }
+    assert_false(@note.applies_to_graphic?(g))
+    assert_true(@content.applies_to_graphic?(g))
+    assert_false(@line_note.applies_to_graphic?(g))
+    assert_false(@line_label_note.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_note.applies_to_graphic?(g))
+    assert_false(@line_label_content.applies_to_graphic?(g))
+    assert_true(@shaped_graphic_content.applies_to_graphic?(g))
+
+    assert_equal(SPLIT_LINES, @content.lines_from(g))
+    assert_equal(SPLIT_LINES, @shaped_graphic_content.lines_from(g))
+  end
+    
+
+  
+  def test_intention_can_apply_to_shaped_graphic_with_note
+    g = shaped_graphic { with_note LINES }
+    assert_true(@note.applies_to_graphic?(g))
+    assert_false(@content.applies_to_graphic?(g))
+    assert_false(@line_note.applies_to_graphic?(g))
+    assert_false(@line_label_note.applies_to_graphic?(g))
+    assert_true(@shaped_graphic_note.applies_to_graphic?(g))
+    assert_false(@line_label_content.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_content.applies_to_graphic?(g))
+    
+    assert_equal(SPLIT_LINES, @note.lines_from(g))
+    assert_equal(SPLIT_LINES, @shaped_graphic_note.lines_from(g))
+  end
+    
+  def test_intention_does_not_apply_to_naked_line
+    
+    g = besheeted(line_graphic)
+    assert_false(@note.applies_to_graphic?(g))
+    assert_false(@content.applies_to_graphic?(g))
+    assert_false(@line_note.applies_to_graphic?(g))
+    assert_false(@line_label_note.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_note.applies_to_graphic?(g))
+    assert_false(@line_label_content.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_content.applies_to_graphic?(g))
+  end
+    
+  def test_intention_can_apply_to_line_graphic_with_note
+    g = besheeted(line_graphic { with_note LINES})
+    assert_true(@note.applies_to_graphic?(g))
+    assert_false(@content.applies_to_graphic?(g))
+    assert_true(@line_note.applies_to_graphic?(g))
+    assert_false(@line_label_note.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_note.applies_to_graphic?(g))
+    assert_false(@line_label_content.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_content.applies_to_graphic?(g))
+
+    assert_equal(SPLIT_LINES, @note.lines_from(g))
+    assert_equal(SPLIT_LINES, @line_note.lines_from(g))
+  end
+    
+  def test_intention_can_apply_to_line_label_with_content
+
+    g = besheeted(line_graphic { graffle_id_is 1},
+                  line_label {
+                    for_line 1
+                    with_content LINES
+                  })
+    assert_false(@note.applies_to_graphic?(g))
+    assert_true(@content.applies_to_graphic?(g))
+    assert_false(@line_note.applies_to_graphic?(g))
+    assert_false(@line_label_note.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_note.applies_to_graphic?(g))
+    assert_true(@line_label_content.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_content.applies_to_graphic?(g))
+
+    assert_equal(SPLIT_LINES, @content.lines_from(g))
+    assert_equal(SPLIT_LINES, @line_label_content.lines_from(g))
+  end
+    
+  def test_intention_can_apply_to_line_label_with_note
+    g = besheeted(line_graphic { graffle_id_is 1},
+                  line_label {
+                    for_line 1
+                    with_note LINES
+                  })
+    assert_true(@note.applies_to_graphic?(g))
+    assert_false(@content.applies_to_graphic?(g))
+    assert_false(@line_note.applies_to_graphic?(g))
+    assert_true(@line_label_note.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_note.applies_to_graphic?(g))
+    assert_false(@line_label_content.applies_to_graphic?(g))
+    assert_false(@shaped_graphic_content.applies_to_graphic?(g))
+
+    assert_equal(SPLIT_LINES, @note.lines_from(g))
+    assert_equal(SPLIT_LINES, @line_label_note.lines_from(g))
+  end
+  
+  def test_intentions_applies_to_text_by_default
+    intention = UserIntention.understand("note is page name")
+    assert_true(intention.applies_to_text?(["some text"]))
+  end
+  
+  def test_intentions_can_be_told_to_match_ignore
+    intention = UserIntention.understand("note with 'ignore'")
+    assert_true(intention.applies_to_text?(["ignore"]))
+    assert_true(intention.applies_to_text?(["line ending with ignore    "]))
+    assert_true(intention.applies_to_text?(["lines, ending, with, ignore"]))
+
+    assert_false(intention.applies_to_text?(["some text"]))
+    assert_false(intention.applies_to_text?(["ignore begins line"]))
+  end
+
+  def test_individual_lines_are_processed_by_default
+    intention = UserIntention.understand("note is page name")
+    assert_true(intention.applies_to_line?(["some text"]))
+  end
+
+  def test_individual_lines_with_more_than_one_word_can_be_skipped
+    intention = UserIntention.understand("notes with one word are page names")
+    assert_false(intention.applies_to_line?("some text"))
+    assert_true(intention.applies_to_line?("text"))
+  end
+
+  def test_individual_lines_can_be_governed_by_ellipses
+    intention = UserIntention.understand("note text... is page name")
+    assert_true(intention.applies_to_line?("some text..."))
+    assert_false(intention.applies_to_line?("ellipses... must end line"))
+  end
+  
+  def test_individual_lines_can_be_handled_with_a_default_clause
+    intention = UserIntention.understand("skip notes with any other kind of line")
+    assert_true(intention.applies_to_line?("some text"))
+    assert_true(intention.applies_to_line?("text"))
+  end
+  
+end
+
+class TestUserIntentionActionsApplied < Test::Unit::TestCase
+  include GraphicalTestsForRails
+  
+  def setup
+    @target = CommandRecorder.new
+  end
+  
+  def assert_last_translation(expected, input)
+    @intention.apply(input, @target)
+    assert_equal(expected, @target.record.last)
+  end
+  
+  def test_do_nothing_action
+    @intention = UserIntention.understand("skip notes")
+    @intention.apply("I am irrelevant", @target)    
+    assert_equal([], @target.record)
+  end
+
+  def test_page_name_action
+    @intention = UserIntention.understand("notes name pages")
+    @intention.apply("MASTER", @target)  
+    @intention.apply("  spaces-outside ", @target)  
+    assert_equal(['assert_on_page("master")', 'assert_on_page("spaces-outside")'], 
+                 @target.record)
+    # TODO: don't know what makes sense for interior spaces or 
+    # non-\w characters.
+  end
+  
+  def test_claim_with_args_in_quotes_action
+    @intention = UserIntention.understand("notes are claims with args in quotes")
+    
+    assert_last_translation('token()', "token")
+    assert_last_translation('underscore_separated_tokens()', 
+                            'underscore separated tokens'
+    )
+    assert_last_translation('whitespace_is_handled_intelligently()',
+                            " whitespace\tis   handled intelligently  "
+     )
+    assert_last_translation('here_is_an("argument")',
+                            'here is an "argument"'
+     )
+     assert_last_translation('single_quotes_are_args("too ")',
+                             " single quotes are args 'too ' "
+     )
+     assert_last_translation('multiple("arguments", "work")',
+                             %q{multiple 'arguments' "work"}
+     )
+     assert_last_translation('only_the("prefix", "command")',
+                             %q{only the 'prefix' is included in the 'command'}
+     )
+
+     assert_last_translation('arguments_can("be", "comma", "separated")',
+                             %q{arguments can 'be', 'comma', and 'separated'}
+     )
+
+     assert_last_translation('stuff_after_the("last", "argument")',
+                             %q{stuff after the 'last' 'argument' is ignored.}
+     )
+
+     assert_last_translation('even_if_it_is_just("a period")',
+                             %q{even if it is just 'a period'.}
+     )
+
+     assert_last_translation('the_method_ignores_punctuation()',
+                             %q{the method (ignores) punctuation.}
+     )
+
+     assert_last_translation('except_that_dashes_become_underscore()',
+                             %q{except that dashes become-underscore}
+     )
+
+     assert_last_translation("its_possible_to_have_quotes_within_words()",
+                             %q{it's possible to have quotes within words}
+     )
+
+     assert_last_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_last_translation("capitals_are_lowercased_throughout()",
+                             %q{Capitals are lowercased THROUGHOUT})
+  end
+  
+  def test_user_action_with_args_in_quotes_action
+    @intention = UserIntention.understand("notes are user actions with args in quotes")
+    assert_last_translation('runs("nathan")',
+                            %q{Nathan runs})
+
+    assert_last_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./) {
+       @intention.apply("runs", @target)
+    }
+  end
+  
+  def test_user_action_logs
+    intention = UserIntention.understand("notes are user actions with args in quotes")
+    log = []
+    intention.apply('Nathan runs', @target, log)
+    assert_equal(['+ runs("nathan")'], log)
+    
+    intention = UserIntention.understand("ignore notes")
+    intention.apply("Nathan runs", @target, log)
+    assert_equal(['+ runs("nathan")', "# 'Nathan runs' ignored."], log)
+    
+  end
+end