graffle 0.1.9 → 0.2.0

data/lib/graphical_tests_for_rails/stereotype-extensions.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-31.
+#  Copyright (c) 2007. All rights reserved.
+
+# These extensions to Graffle allow code here to give 
+# stereotyped names to visual thingees and generate method
+# calls from them. 
+#
+# TODO: Should these be moved into Graffle proper? On the one 
+# hand, some of them (esp. the queries) could be useful. On the other, 
+# they have weird names (especially in the more specific modules.)
+
+# These methods are tested via the user-intention-tests.
+
+
+require 'graffle/stereotypes'
+
+module Graffle 
+  
+  module AbstractGraphic
+    # These are utilities of use when you're handed an 
+    # abstract graphic and want to know something about it.
+
+    def is_labeled_line? # :nodoc:
+      return false unless behaves_like?(LineGraphic)
+      has_label?
+    end
+
+    def has_line_label_note? # :nodoc:
+      is_labeled_line? && label.has_note?
+    end
+
+    def has_line_label_content? # :nodoc:
+      is_labeled_line? && label.has_content?
+    end
+
+    def has_line_note? # :nodoc:
+      behaves_like?(LineGraphic) && has_note?
+    end
+
+    def has_shaped_graphic_note? # :nodoc:
+      behaves_like?(ShapedGraphic) && has_note?
+    end
+
+    def has_shaped_graphic_content? # :nodoc:
+      behaves_like?(ShapedGraphic) && has_content?
+    end
+
+    def has_any_content? # :nodoc:
+      return true if behaves_like?(ShapedGraphic) && has_content?
+      has_line_label_content?
+    end
+
+    def has_any_note? # :nodoc:
+      return true if has_note?
+      has_line_label_note?
+    end
+
+
+    def any_content_lines # :nodoc:
+      if has_shaped_graphic_content?
+        shaped_graphic_content_lines
+      elsif has_line_label_content?
+        line_label_content_lines
+      else
+        user_is_bewildered("#{self.inspect} doesn't have content.")
+      end
+    end
+
+
+    def any_note_lines # :nodoc:
+      if has_shaped_graphic_note?
+        shaped_graphic_note_lines
+      elsif has_line_note?
+        line_note_lines
+      elsif has_line_label_note?
+        line_label_note_lines
+      else
+        user_is_bewildered("#{self.inspect} doesn't have content.")
+      end
+    end
+  end  
+  
+  module ShapedGraphic
+    def shaped_graphic_note_lines # :nodoc:    # can be automatically generated
+      note.as_lines
+    end
+  
+    def shaped_graphic_content_lines # :nodoc: # can be automatically generated
+      content.as_lines
+    end
+  end
+  
+  module LineGraphic
+    def line_note_lines # :nodoc:       # can be called by generated code
+      note.as_lines
+    end
+    
+    def line_label_content_lines # :nodoc     # can be called by generated code
+      label.content.as_lines
+    end
+    
+    def line_label_note_lines # :nodoc:       # can be called by generated code
+      label.note.as_lines
+    end
+    
+  end
+
+end
+

data/lib/graphical_tests_for_rails/text-appliers.rb

@@ -1,44 +1,14 @@
 #!/usr/bin/env ruby
-#
-#  Created by Brian Marick on 2007-07-21.
+#  Created by Brian Marick on 2007-07-23.
 #  Copyright (c) 2007. All rights reserved.
+"prevent the above from infecting rdoc"
 
 module GraphicalTestsForRails
   
   # Just a wrapper module so that classes are grouped nicely in rdoc.
   # You don't have to include this - that happens if you require
   # graphical_tests_for_rails.rb.
-  module TextAppliers
-
-    # This is the base class for objects that know how to convert text
-    # into a series of messages and send them to some target.
-    class AbstractTextApplier
-
-      # apply is given an array of text (_lines_). It is to convert
-      # that text into messages and send them to _target_.
-      #
-      def apply(lines, target)
-        message_sends = lines.collect {|line| message_and_args_from(line) }
-        message_sends.each do |m| 
-          Fluid.log << readable(*m)
-          target.send(*m) 
-        end
-      end
-
-      # message_and_args_from is given a string that is derived from some
-      # text. It must answer an array whose first element is a
-      # message name and whose remaining elements are appropriate message
-      # arguments. Must be defined in any subclass.
-      def message_and_args_from; subclass_responsibility; end
-
-      private
-      def readable(message, *args)
-        inspected = args.collect { |a| a.inspect }
-        "+ #{message}(#{inspected.join(', ')})"
-      end
-
-
-    end
+  module TextAppliers # :nodoc: all
 
 
     # The arguments to apply are quoted within the _string_. 
@@ -48,30 +18,7 @@ module GraphicalTestsForRails
     # means this:
     #    target.paul_logs_in_with("john", "j")
     #
-    class ArgsFromQuotedText < AbstractTextApplier
-
-      def message_and_args_from(string)
-        quote_marker = '%<<<==-'
-
-        string = string.gsub(/(\w)'(\w)/, "#{quote_marker}\\1\\2#{quote_marker}")
-        tokens = string.split(/['"],?/, allow_trailing_null_fields = -1)
-        message = tokens[0].strip.downcase
-        args = tokens[1..-1]
-
-
-        message.gsub!(/#{quote_marker}(.)(.)#{quote_marker}/, "\\1\\2")
-        message.gsub!(/\s+/,'_')
-        message.gsub!(/-/, '_')
-        message.gsub!(/\W/, '')
-
-
-        args = args.enum_slice(2).collect { |e| e[0] } 
-        args = args.collect do | arg | 
-          arg.gsub(/#{quote_marker}(.)(.)#{quote_marker}/, "\\1'\\2")
-        end
-
-        [message] + args
-      end
+    class ArgsFromQuotedText
     end
 
     # Like ArgsFromQuotedText, but the first word (typically a name)
@@ -82,17 +29,7 @@ module GraphicalTestsForRails
     #    target.logs_in_with("paul", "john", "j")
     #
 
-    class PrefixNameAndArgsFromQuotedText < ArgsFromQuotedText
-      def message_and_args_from(string)
-        user_claims(string =~ /^\s*(\w+)\s+(.*)$/) {
-          "'#{string}' cannot be split into a name and an action."
-        }
-        name = $1.downcase
-        rest = super($2)
-        message = rest.shift
-        [message, name, *rest]
-      end
-
+    class PrefixNameAndArgsFromQuotedText
     end
 
 
@@ -103,33 +40,22 @@ module GraphicalTestsForRails
     #    applier.apply("HOME")
     # turns into this:
     #    applier.assert_on("home")
-    class TextAsNameOfPage < AbstractTextApplier
+    class TextAsNameOfPage
 
       # When producing a method call, objects of this class will 
       # prepend the _message_ to
       # a single argument it constructs.
       def initialize(message)
+        user_claims(message == 'assert_on_page') {
+          "At the moment, a TextAsNameOfPage must be given assert_on_page."
+        }
         @message = message
       end
-
-      # All of the text in the _string_ is expected to be the name 
-      # of a page. It is downcased and treated as the single argument to 
-      # the message passed to +new+.
-      def message_and_args_from(string)
-        [@message, string.downcase.strip]
-      end
     end
 
     class TextApplierThatDoesNothing # :nodoc:
-      def message_and_args_from(string) 
-        [:object_id] # no_op
-      end
-
-      def apply(lines, target)
-        # do nothing, don't even bother sending a no-op
-      end
     end
-
+    
   end
   
 end

data/lib/graphical_tests_for_rails/user-intention.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-31.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'enumerator'
+require 'graphical_tests_for_rails/stereotype-extensions'
+require 'graphical_tests_for_rails/jumbled-string-canonicalizer'
+
+module GraphicalTestsForRails
+  class UserIntention # :nodoc:
+    include GraphicalTestsForRails
+    
+    module Names
+      USER_MEANS_LINE_LABEL_NOTE = "line_label_note"
+      USER_MEANS_LINE_LABEL_CONTENT = "line_label_content"
+      USER_MEANS_LINE_NOTE = "line_note"
+      USER_MEANS_SHAPED_GRAPHIC_NOTE = "shaped_graphic_note"
+      USER_MEANS_SHAPED_GRAPHIC_CONTENT = "shaped_graphic_content"
+      USER_MEANS_ANY_CONTENT = "any_content"
+      USER_MEANS_ANY_NOTE = "any_note"
+      
+      USER_MEANS_CONTAINS_IGNORE = "contains_ignore"
+      
+      USER_MEANS_LINES_WITH_ONE_WORD = "line_with_one_word"
+      USER_MEANS_LINE_ENDS_WITH_ELLIPSES = "ends_with_ellipses"
+      USER_MEANS_REMAINING_LINES = "catch_all_for_lines"
+      
+      USER_MEANS_ACTOR_ACTION_WITH_QUOTE_ARGS = "user_action_quote_args"
+      USER_MEANS_CLAIM_WITH_QUOTE_ARGS = "claim_quote_args"
+      USER_MEANS_PAGE_NAME = "page_name"
+      USER_MEANS_DO_NOTHING = "do_nothing"
+      
+    end
+    include Names
+    
+    DISAMBIGUATE_BY_WORD_COUNT = proc { |a, b| 
+      # The 'compact' is needed to get rid of non-matching alternatives
+      # in something like /(foo)|(bar)/.
+      words = proc { | x | - x.raw_reason.compact.length }
+      words[a] <=> words[b]
+    }
+    
+    LINE_LABEL_REGEXP = /\b(line)\s+(labels?)\b/
+    NOTE_REGEXP = /\b(notes?)|(annotations?)\b/
+    CONTENT_REGEXP = /\b(contents?)\b/
+    LINE_REGEXP = /\b(lines?)\b/
+    SHAPED_GRAPHIC_REGEXP = /\b(shaped\s+graphics?)|(shapes?)\b/
+    
+    PLACE = {
+      [LINE_LABEL_REGEXP, NOTE_REGEXP] => USER_MEANS_LINE_LABEL_NOTE,
+      [LINE_LABEL_REGEXP, CONTENT_REGEXP] => USER_MEANS_LINE_LABEL_CONTENT,
+      [LINE_REGEXP, NOTE_REGEXP] => USER_MEANS_LINE_NOTE,
+      [SHAPED_GRAPHIC_REGEXP, NOTE_REGEXP] => USER_MEANS_SHAPED_GRAPHIC_NOTE,
+      [SHAPED_GRAPHIC_REGEXP, CONTENT_REGEXP] => USER_MEANS_SHAPED_GRAPHIC_CONTENT,
+      [CONTENT_REGEXP] => USER_MEANS_ANY_CONTENT,
+      [NOTE_REGEXP] => USER_MEANS_ANY_NOTE,
+    }
+    PLACER = JumbledStringCanonicalizer.new(PLACE) {
+      disambiguate &DISAMBIGUATE_BY_WORD_COUNT
+      no_match_message { | source | "'#{source}' does not refer to any graphic."}
+    }    
+
+    TEXTS = {
+      [/\b(ignore)\b/] => USER_MEANS_CONTAINS_IGNORE,
+    }
+    TEXTER = JumbledStringCanonicalizer.new(TEXTS) {
+      default nil
+    }
+    
+
+    QUOTED_ARGS_REGEXPS = [/\b(quote\w*)\b/, /\b(arg\w*)\b/]
+    ACTIONS = {
+      [/\b(skip)|(ignore)\b/] => USER_MEANS_DO_NOTHING,
+      [/\b(user)\s+(actions?)\b/] + QUOTED_ARGS_REGEXPS => USER_MEANS_ACTOR_ACTION_WITH_QUOTE_ARGS,
+      [/\b(claims?)\b/] + QUOTED_ARGS_REGEXPS => USER_MEANS_CLAIM_WITH_QUOTE_ARGS,
+      [/\b(names?)\b/, /\b(pages?)\b/] => USER_MEANS_PAGE_NAME,
+    }
+    ACTIONER = JumbledStringCanonicalizer.new(ACTIONS) {
+      no_match_message { | source | "'#{source}' doesn't say what should happen in the test."}
+      multiple_match_message { | source, pretty_reasons, raw_reasons | 
+        pretty_reasons = pretty_reasons.sort_by { |r| r.length }
+        "'#{source}' implies conflicting instructions:\n" + 
+        "One is from these words: #{pretty_reasons[0]}\n" + 
+        pretty_reasons[1..-1].collect { |r| "Another is from these: #{r}" }.join("\n")
+      }
+      
+    }
+
+    OTHER_KIND_REGEXP = '(\b(other)\s+(kinds?)\s+(of)\b)'
+    OTHERWISE_REGEXP = '(\botherwise\b)'
+    LINE_GUARDS = {
+      [/\b(with)\s+.*\b(one)\s+(word)\b/] => USER_MEANS_LINES_WITH_ONE_WORD,
+      [/\b(ellipses)\b/] => USER_MEANS_LINE_ENDS_WITH_ELLIPSES,
+      [/\b(text\.\.\.*)/] => USER_MEANS_LINE_ENDS_WITH_ELLIPSES,
+      [/#{OTHERWISE_REGEXP}|#{OTHER_KIND_REGEXP}/] => USER_MEANS_REMAINING_LINES,
+    }
+    GUARDER = JumbledStringCanonicalizer.new(LINE_GUARDS) {
+      default nil
+    }
+    
+    attr_reader :place, :text, :action, :line_guard, :source
+    
+    def to_s
+      retval = "'#{source}' produces:\n"
+      retval += "\t#{action.value} if #{place.value}"
+      retval += " && #{text.value}" if text.value 
+      retval += " && #{line_guard.value}" if line_guard.value 
+      retval
+    end
+    def inspect; to_s; end
+
+    def self.understand(instruction)
+      prog1(new) { | i | i.understand(instruction) }
+    end
+    
+    def understand(instruction)
+      @source = instruction
+      understand_place(instruction)
+      understand_text(instruction)
+      understand_action(instruction)
+      understand_line_guard(instruction)
+    end
+    
+    def understand_place(instruction)
+      @place = PLACER.canonicalize(instruction)
+    end
+    
+    def understand_text(instruction)
+      @text = TEXTER.canonicalize(instruction)
+    end
+    
+    def understand_action(instruction)
+      @action = ACTIONER.canonicalize(instruction)
+    end
+    
+    def understand_line_guard(instruction)
+      @line_guard = GUARDER.canonicalize(instruction)
+    end
+    
+    def applies_to_graphic?(graphic)
+      graphic.send('has_' + place.value + '?')
+    end
+    
+    def lines_from(graphic)
+      lines = graphic.send(place.value + '_lines')
+      lines.collect { |l| l.strip }.find_all { |l| l != '' }
+    end
+    
+    def applies_to_text?(lines)
+      return true if text.value.nil?
+      send(text.value + '?', lines)
+    end
+      
+      
+    def contains_ignore?(lines)
+      lines.any? { |l| l.strip.ends_with?("ignore") }
+    end
+    
+    def applies_to_line?(line)
+      return true if line_guard.value.nil?
+      send(line_guard.value + '_acceptable?', line)
+    end
+    
+    def line_with_one_word_acceptable?(line)
+      line.split(' ').length == 1
+    end
+    
+    def ends_with_ellipses_acceptable?(line)
+      line.strip =~ /\.\.+$/
+    end
+    
+    def catch_all_for_lines_acceptable?(line)
+      true
+    end
+    
+    def apply(string, target, log = [])
+      Applier.new(target, log).send("apply_" + action.value, string)
+    end
+    
+    class Applier
+      def initialize(target, log)
+        @target = target
+        @log = log
+      end
+      
+      def do_it(*message_send)
+        @log << readable(*message_send)
+        @target.send(*message_send)
+      end
+      
+      
+      def apply_user_action_quote_args(string)
+        user_claims(string =~ /^\s*(\w+)\s+(.*)$/) {
+          "'#{string}' cannot be split into a name and an action."
+        }
+        name = $1.downcase
+        rest = message_and_quote_args($2)
+        message = rest.shift
+        do_it(message, name, *rest)
+      end
+      
+      
+      def apply_claim_quote_args(string)
+        do_it(*message_and_quote_args(string))
+      end
+      
+      def apply_page_name(string)
+        do_it('assert_on_page', string.downcase.strip)
+      end
+      
+      def apply_do_nothing(string)
+        @log << "# '#{string}' ignored."
+      end
+      
+      private 
+      def message_and_quote_args(string)
+        quote_marker = '%<<<==-'
+
+        string = string.gsub(/(\w)'(\w)/, "#{quote_marker}\\1\\2#{quote_marker}")
+        tokens = string.split(/['"],?/, allow_trailing_null_fields = -1)
+        message = tokens[0].strip.downcase
+        args = tokens[1..-1]
+
+
+        message.gsub!(/#{quote_marker}(.)(.)#{quote_marker}/, "\\1\\2")
+        message.gsub!(/\s+/,'_')
+        message.gsub!(/-/, '_')
+        message.gsub!(/\W/, '')
+
+
+        args = args.enum_slice(2).collect { |e| e[0] } 
+        args = args.collect do | arg | 
+          arg.gsub(/#{quote_marker}(.)(.)#{quote_marker}/, "\\1'\\2")
+        end
+
+        [message] + args
+      end
+      
+      def readable(message, *args)
+        inspected = args.collect { |a| a.inspect }
+        "+ #{message}(#{inspected.join(', ')})"
+      end
+
+      
+      
+      
+    end
+  end
+end