graffle 0.1.9 → 0.2.0

data/test/abstract-graphic-tests.rb

@@ -101,4 +101,14 @@ class TestAbstractGraphics < Test::Unit::TestCase
     assert_true(s.find_by_id(333).note.behaves_like?(Graffle::Note))
   end
   
+  def test_abstract_graphics_in_collections_can_delete_themselves
+    s = sheet {
+      with shaped_graphic { graffle_id_is 1}
+    }
+    
+    g = s.find_by_id(1)
+    g.delete_yourself
+    assert_equal(nil, s.find_by_id(1))
+  end
+  
 end

data/test/container-tests.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-25.
+#  Copyright (c) 2007. All rights reserved.
+
+# TODO: Some tests from sheets and groups could probably be moved here.
+
+
+require "set-standalone-test-paths.rb" unless $started_from_rakefile
+require 'test/unit'
+require 's4t-utils'
+include S4tUtils
+require 'test/util'
+
+require 'graffle'
+
+class TestContainers < Test::Unit::TestCase
+  include Graffle
+  include Graffle::Builders
+
+  def test_deletion
+    s = sheet { 
+      with line_graphic { graffle_id_is 1 }
+    }
+    g = s.find_by_id(1)
+    s.delete_graphic(g)
+    assert_nil(s.find_by_id(1))
+  end
+end

data/test/graphical_tests_for_rails/jumbled-string-canonicalizer-tests.rb

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-29.
+#  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 'graphical_tests_for_rails/jumbled-string-canonicalizer'
+
+class TestJumbledStringCanonicalizer < Test::Unit::TestCase
+  include GraphicalTestsForRails
+  
+  def test_simple_canonicalization_selects_one_string
+    patterns = {
+      [/\b(ones?)\b/] => "one",
+    }
+
+    izer = JumbledStringCanonicalizer.new(patterns)
+    canonical = izer.canonicalize(s = "they are the ones.")
+    assert_equal("one", canonical.value)
+    assert_equal(s, canonical.source)
+    assert_equal([['ones']], canonical.raw_reason)
+    assert_equal("'ones'", canonical.pretty_reason)
+  end
+  
+  def test_canonicalization_can_have_more_than_one_regexp
+    patterns = {
+      [/\b(ones?\stwos?)\b/] => "wrong",
+      [/\b(ones?)\b/, /\b(twos?)\b/] => "one two",
+    }
+    
+    izer = JumbledStringCanonicalizer.new(patterns)
+    canonical = izer.canonicalize(s = "two is two ones")
+    assert_equal("one two", canonical.value)
+    assert_equal(s, canonical.source)
+    assert_equal([['ones'], ['two']], canonical.raw_reason)
+    assert_equal("'ones'; and also 'two'", canonical.pretty_reason)
+  end
+  
+  def test_raw_reasons_are_available
+    patterns = {
+      [/\b(a)\s+(cs?)\b/, /\b(d+).*?(e+).*?(f)\b/] => "success",
+    }
+
+    izer = JumbledStringCanonicalizer.new(patterns)
+    canonical = izer.canonicalize(s = "ddd a cs ee not included f")
+    assert_equal("success", canonical.value)
+
+    assert_equal([["a", "cs"], ["ddd", "ee", "f"]], canonical.raw_reason)
+  end
+  
+  def test_raw_reasons_do_not_include_nil_alternatives
+    patterns = {
+      [/(a)|(b)/] => "success",   
+    }
+
+    izer = JumbledStringCanonicalizer.new(patterns)
+    canonical = izer.canonicalize(s = "a")  # $1 = 'a', $2 = nil
+    assert_equal([["a"]], canonical.raw_reason)
+  end
+  
+  def test_reasons_can_be_produced_prettily
+    patterns = {
+      [/\b(a)\s+(cs?)\b/, /\b(d+).*?(e+).*?(f)\b/] => "success",
+    }
+    
+    izer = JumbledStringCanonicalizer.new(patterns)
+    canonical = izer.canonicalize(s = "ddd a cs ee not included f")
+    assert_equal("success", canonical.value)
+    assert_equal("'a' and 'cs'; and also 'ddd', 'ee', and 'f'", canonical.pretty_reason)
+  end
+  
+  def test_normally_no_match_is_an_error
+    izer = JumbledStringCanonicalizer.new
+    assert_raise_with_matching_message(StandardError,
+                                      /Cannot recognize.*'foo'/) { 
+          izer.canonicalize("foo") 
+    }
+  end
+  
+  def test_the_no_match_error_message_can_be_customized
+    izer = JumbledStringCanonicalizer.new {
+      no_match_message {|source| "Dude! What's with '#{source}'?"}
+    }
+    assert_raise_with_matching_message(StandardError, /Dude! What's with 'foo'\?/) { 
+      izer.canonicalize("foo") 
+    }
+  end
+  
+  def test_there_can_be_a_default_value_in_case_of_no_match
+    patterns = {
+      [/\b(ones?\stwos?)\b/] => "wrong",
+      [/\b(ones?)\b/, /\b(twos?)\b/] => "one two",
+    }
+    izer = JumbledStringCanonicalizer.new(patterns) {
+      default "default"
+    }
+    canonical = izer.canonicalize(s = "ddd a cs ee not included f")
+    assert_equal("default", canonical.value)
+    assert_equal(s, canonical.source)
+    assert_equal([], canonical.raw_reason)
+    assert_equal("no matching words", canonical.pretty_reason)
+  end
+  
+  def test_nil_is_a_fine_default_value
+    izer = JumbledStringCanonicalizer.new {
+      default nil
+    }
+    canonical = izer.canonicalize(s = "match me!")
+    assert_equal(nil, canonical.value)
+    assert_equal(s, canonical.source)
+    assert_equal([], canonical.raw_reason)
+    assert_equal("no matching words", canonical.pretty_reason)
+  end
+  
+  def test_normally_multiple_matches_are_an_error
+    patterns = {
+      [/(one) (two)/] => 'one',
+      [/(two)/] => 'two'
+    }
+    izer = JumbledStringCanonicalizer.new(patterns) 
+    assert_raise_with_matching_message(StandardError,
+                                      /Multiple matches in 'one two'.*'one' and 'two'/m) { 
+      # Can't check both match reasons because order is unknown.
+      izer.canonicalize("one two") 
+    }
+  end
+  
+  def test_the_multiple_match_error_can_be_customized_using_pretty_reasons
+    patterns = {
+      [/(one) (two)/, /(one)/] => 'one',
+      [/(one) (two)/] => 'two'
+    }
+    izer = JumbledStringCanonicalizer.new(patterns) {
+      multiple_match_message { | source, pretty_reasons, raw_reasons | 
+        pretty_reasons = pretty_reasons.sort_by { |r| r.length }
+        "Could not match '#{source}' for multiple reasons:\n" + 
+        "One match is against these words: #{pretty_reasons[0]}\n" + 
+        pretty_reasons[1..-1].collect { |r| "Another is against these: #{r}" }.join("\n")
+      }
+    }
+    assert_raise_with_matching_message(StandardError,
+        /not match 'one two'.*One match.*'one' and 'two'.*Another.*'one' and 'two'.*also 'one'/m) { 
+        izer.canonicalize("one two") 
+    }
+  end
+    
+  def test_multiple_matches_can_be_disambiguated
+    patterns = {
+      [/(one) (two)/] => 'one',
+      [/(two)|(one)|(three)/] => 'two'
+    }
+    izer = JumbledStringCanonicalizer.new(patterns) {
+      disambiguate { |a, b| 
+        words = proc { | x | - x.raw_reason.flatten.compact.length }
+        words[a] <=> words[b]
+      }
+    }
+    canonical = izer.canonicalize(s = "one two")
+    assert_equal("one", canonical.value)
+    assert_equal(s, canonical.source)
+    assert_equal("'one' and 'two'", canonical.pretty_reason)
+  end
+  
+  
+  
+  
+end

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

@@ -0,0 +1,286 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-25.
+#  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 NewStylePictureApplierTest < Test::Unit::TestCase
+  include Graffle 
+  include Graffle::Builders
+  include GraphicalTestsForRails
+
+  def setup
+    @sheet = sheet { 
+      with shaped_graphic { 
+        graffle_id_is 1
+          with_content "just a comment"
+          with_note 'ignore' 
+        }
+        
+      with shaped_graphic { 
+        graffle_id_is 11
+          with_content "PAGE"
+        }
+
+      with line_label {  
+        for_line 22
+        with_content "fred tests the label text"
+      }
+      with line_graphic {
+        graffle_id_is 22
+      }
+      with shaped_graphic {
+        with_content "Key"
+        with_note %Q{skip graphics with an "ignore" annotation
+                     
+                     line label contents are user actions with args in quotes
+                     shape content names a page
+                    } 
+      }
+    
+    }
+  end
+  
+  
+  def test_from_sheet_requires_key
+    assert_raises_with_matching_message(StandardError, /has no key/) do
+      PictureApplier.from_sheet(sheet)
+    end
+  end
+  
+  
+  def test_but_defaults_can_be_used_instead_of_key
+    applier = PictureApplier.from_sheet(sheet, 
+                                    "notes are claims with quoted args", 
+                                    "contents are page names")
+
+    matches = lambda do |graphic|
+      ints = applier.intentions_that_apply_to(graphic)
+      ints.collect { |i| i.source }
+    end
+    
+    benoted = shaped_graphic { with_note "fred" }
+    contented = shaped_graphic { with_content "barry" }
+    
+    assert_equal(["notes are claims with quoted args"], matches[benoted])
+    assert_equal(["contents are page names"], matches[contented])
+  end
+  
+  
+  def test_from_sheet_key_requires_notes
+    assert_raises_with_matching_message(StandardError, /supposed to have an annotation/) do
+      s = sheet {
+        with shaped_graphic {
+          with_content "key"
+        }
+      }
+      PictureApplier.from_sheet(s)
+    end
+  end
+  
+  def test_from_sheet_key_contents_must_be_recognized
+    assert_raises_with_matching_message(StandardError, /does not refer to any graphic/) do
+      s = sheet {
+        with shaped_graphic {
+          with_content "key"
+          with_note "missing"
+        }
+      }
+      PictureApplier.from_sheet(s)
+    end
+  end
+  
+  def test_graphics_are_filtered_by_place
+    any_note = "match any note (action would be skip)"
+    any_shape_note = "match any shape note (action would be skip)"
+    kp = PictureApplier.from_written_intentions(any_note, any_shape_note)
+
+    matches = lambda do |graphic|
+      ints = kp.intentions_that_apply_to(graphic)
+      ints.collect { |i| i.source }
+    end
+
+    assert_equal([], matches[shaped_graphic])
+    assert_equal([], matches[shaped_graphic {with_content "t"}])   
+    assert_equal([any_note], 
+                 matches[besheeted(line_graphic { with_note "hi"})])
+    assert_equal([any_note, any_shape_note], 
+                 matches[shaped_graphic {with_note "t"}])   
+  end
+
+  def test_graphics_can_be_ignored
+    skipper = "skip if note says 'ignore'"
+    kp = PictureApplier.from_written_intentions(skipper)
+
+    matches = lambda do |graphic|
+      ints = kp.intentions_that_apply_to(graphic)
+      ints.collect { |i| i.source }
+    end
+
+    assert_equal([], matches[shaped_graphic])
+    assert_equal([], matches[shaped_graphic {with_content "t"}])   
+    assert_equal([], 
+                 matches[besheeted(line_graphic { with_note "hi"})])
+    assert_equal([skipper], 
+                 matches[shaped_graphic {with_note "ignore"}])   
+  end
+
+  def test_application_of_intentions
+    @applier = PictureApplier.from_sheet(@sheet)    
+    target = CommandRecorder.new
+    @applier.apply(@sheet.graphics_without_labels, target)    
+    assert_equal(['assert_on_page("page")', 'tests_the_label_text("fred")'], 
+                 target.record)
+  end
+  
+  def test_action_must_be_recognized
+    assert_raises_with_matching_message(StandardError, /doesn't say what should happen/) do
+      s = sheet {
+        with shaped_graphic {
+          with_content "key"
+          with_note "note with friends dines"
+        }
+      }
+      PictureApplier.from_sheet(s)
+    end
+  end
+  
+  def test_different_lines_can_cause_different_actions
+    s = sheet { 
+      with shaped_graphic { 
+        graffle_id_is 1
+          with_content %Q{page\njohn logs in as "john".}
+        }
+        
+      with shaped_graphic {
+        with_content "Key"
+        with_note %Q{shape content with one word is page name
+                     otherwise, shape content is user action with args in quotes
+                    } 
+      }
+    }
+    applier = PictureApplier.from_sheet(s)    
+    target = CommandRecorder.new
+    applier.apply(s.graphics_without_labels, target)    
+    assert_equal(['assert_on_page("page")', 'logs_in_as("john", "john")'], 
+               target.record)
+  end
+  
+  def test_empty_graphics_are_gracefully_ignored
+    s = sheet {
+      with shaped_graphic
+      with line_graphic
+    }
+    
+    applier = PictureApplier.from_written_intentions(
+      "notes are page names",
+      "contents are page names"
+    )
+    
+    applier.apply(s.graphics_without_labels, nil)
+  end
+  
+  def test_non_empty_graphics_that_do_not_match_are_too
+    s = sheet {
+      with shaped_graphic { with_content "hi"}
+      with line_label {
+        for_line 1
+        with_content "bye"
+      }
+      with line_graphic {
+        graffle_id_is 1
+      }
+    }
+    
+    applier = PictureApplier.from_written_intentions(
+      "notes are page names"
+    )
+    
+    applier.apply(s.graphics_without_labels, nil)
+  end
+
+  def test_lines_that_do_not_match_are_ignored
+    s = sheet {
+      with shaped_graphic { with_content "only line ignored"}
+      with line_label {
+        for_line 1
+        with_content "multiple lines\n\nare ignored but single are\nnot"
+      }
+      with line_graphic {
+        graffle_id_is 1
+      }
+    }
+    
+    applier = PictureApplier.from_written_intentions(
+      "content lines with one word are page names"
+    )
+    
+    target = CommandRecorder.new
+    applier.apply(s.graphics_without_labels, target)    
+    assert_equal(['assert_on_page("not")'], 
+               target.record)
+  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
+  
+  
+  
+  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 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.from_written_intentions(
+      "shape content is page name"
+      )
+    begin
+      @applier.apply(four_counting_shaped_graphics, ThriceThenDie.new)
+      flunk "never reached"
+    rescue Test::Unit::AssertionFailedError => e 
+      assert_thrice_then_die_log(e, four_graphic_contents)
+    end
+  end
+  
+end