graffle 0.1.7 → 0.1.8

data/lib/graffle/stereotypes.rb

@@ -97,9 +97,14 @@ module Graffle
       self.origin < other.origin
     end
     
+    # Is this object the label for some LineGraphic?
+    def is_line_label?; self.has_key?('Line'); end
+    
     # A Point. Must be defined in the whatever includes this module.
     def origin; includer_responsibility; end
     
+    
+    
   end
   
   
@@ -172,9 +177,6 @@ module Graffle
     # double-click on the object.)
     def has_content?; self.has_key?('Text'); end    
     
-    # Is this object the label for some LineGraphic?
-    def is_line_label?; self.has_key?('Line'); end
-    
     def act_as_line_label  # :nodoc:
       
       def self.for_line(graffle_id) # :nodoc:
@@ -316,7 +318,9 @@ module Graffle
     def go_to(thing); _link__bemhack('Head', thing); end
 
     def _follow__bemhack(which)
-      container.find_by_id(self[which]['ID'])
+      endpoint = self[which]
+      return nil unless endpoint
+      container.find_by_id(endpoint['ID'])
     end
   
     # TODO: note this is no good for updating, since fields other than
@@ -385,6 +389,13 @@ module Graffle
       self['GraphicsList']
     end
     
+    # Labels for lines are independent ShapedGraphic objects that
+    # point to LineGraphic objects, so graphics will return them. 
+    # This method omits them. 
+    def graphics_without_labels
+      graphics.reject { |g| g.is_line_label? }
+    end
+    
     # Only the LineGraphic objects within the Sheet.
     def all_lines
       graphics.find_all do | g |

data/lib/graffle/styled-text-reader.rb

@@ -3,6 +3,9 @@
 #  Created by Brian Marick on 2007-07-06.
 #  Copyright (c) 2007. All rights reserved.
 
+# ActiveSupport also defines starts_with? but for some reason the tests
+# hang if I try to require it instead. 
+require 'extensions/string' unless String.method_defined?('starts_with?')
 
 module Graffle
 

data/lib/graffle/version.rb

@@ -4,5 +4,5 @@
 #  Copyright (c) 2007. All rights reserved.
 
 module Graffle
-  Version = '0.1.7'
+  Version = '0.1.8'
 end

data/lib/graphical_tests_for_rails.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-10.
+#  Copyright (c) 2007. All rights reserved.
+
+
+
+require 'graffle'
+require 'graphical_tests_for_rails/interpreters'
+require 'graphical_tests_for_rails/orderings'
+
+# Classes within this module help you build up Rails integration tests
+# from OmniGraffle files. The important classes are these:
+#
+# * GraphicInterpreter: These objects are 'programmed' with
+#   AbstractMessageMakers who know how to convert lines of text
+#   into messages and arguments to send to a _target_.
+# * GraphicOrderer: These objects take a list of graphics in no
+#   particular order and put it in the right order for a particular
+#   style of test. For example, a WorkflowOrder represents an 
+#   order created by tracing through shapes connected by lines.
+
+module GraphicalTestsForRails
+  
+end

data/lib/graphical_tests_for_rails/interpreters.rb

@@ -0,0 +1,147 @@
+require 'enumerator'
+require 'test/unit/assertionfailederror'
+
+module GraphicalTestsForRails
+  
+  # A GraphicInterpreter takes a list of _graphics_, some 
+  # instructions about how to interpret them, and a _target_.
+  # It interprets the instructions to create messages that it then 
+  # sends to the target.
+  #
+  class GraphicInterpreter
+
+    # The _graphics_ are an array of OmniGraffle AbstractGraphic objects. The 
+    # _instructions_ map a string to an object that must respond to 
+    # produce_method_call. (See AbstractMessageMaker#produce_method_call
+    # for more.)
+    #
+    # Here are the available instructions (keys in _instructions_):
+    #
+    # * ['line labels' => ...]: each line within the (single)
+    #   label on the line is to be interpreted as a message-send by an 
+    #   instance of the given class.
+    # * ['shaped graphic text' => ...]: each line of content
+    #   within the graphic is to be interpreted by the given class. The 
+    #   content is the text you type in an object after double-clicking
+    #   on it.
+    # * ['text...' => ...]: a line ending in ellipses is treated this way,
+    #   no matter what other instructions say. 
+    #
+    def initialize(graphics, instructions = {})
+      @graphics = graphics
+      @line_label_strategy = 
+          instructions['line labels'] 
+      @shaped_graphic_text_strategy = 
+          instructions['shaped graphic text']
+          
+      @ellipses_override = instructions['text...']
+    end
+    
+    # Apply the _graphics_, according to the _instructions_, against
+    # the _target_.
+    def run_against(target)
+      @target = target
+      @log = []
+      @graphics.each do |g|
+        case g.stereotype.basename
+        when "ShapedGraphic"
+          process_commands(@shaped_graphic_text_strategy,
+                           g.content.as_lines)
+        when "LineGraphic"
+          process_commands(@line_label_strategy,
+                           g.label_lines)
+        end
+      end
+    end
+        
+    private
+    
+    def process_commands(command_maker, command_lines)
+      return if command_maker.nil?
+      command_lines.each do |line|
+        info = if /\.\.\.\s*$/ =~ line && @ellipses_override
+                 @ellipses_override.produce_method_call(line)
+               else
+                 command_maker.produce_method_call(line)
+               end
+        begin
+          @log << readable(*info)
+          @target.send(*info)
+        rescue Test::Unit::AssertionFailedError, StandardError, ScriptError => e
+          raise e.class.new(%Q{#{e.message} after\n#{@log.join("\n")}})
+        end
+      end    
+    end
+    
+    def readable(message, *args)
+      inspected = args.collect { |a| a.inspect }
+      "+ #{message}(#{inspected.join(', ')})"
+    end
+      
+  end
+  
+  class AbstractMessageMaker
+    # produce_method_call is given a string that is derived from some
+    # text somewhere associated with a graphic (label, contents of text
+    # box, annotation). It must answer an array whose first element is a
+    # message name. That message, along with any remaining array elements,
+    # is sent to the target.
+    #
+    # This class only exists so there's a place to hang this comment.
+    def produce_method_call; subclass_responsibility; end
+  end
+  
+    
+  class ArgsFromQuotedText < AbstractMessageMaker
+    
+    # The arguments are quoted within the _string_. 
+    # The message is the text before the first arg, snake-cased.
+    def produce_method_call(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
+  end
+  
+  
+  class TextIsNameOfPage
+    
+    # When producing a method call, objects of this class will 
+    # prepend the _message_ to
+    # a single argument it constructs.
+    def initialize(message)
+      @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 produce_method_call(string)
+      [@message, string.downcase.strip]
+    end
+  end
+  
+  class Ineffectual # :nodoc:
+    def produce_method_call(string)
+      [:object_id] # no_op
+    end
+  end
+end
+

data/lib/graphical_tests_for_rails/orderings.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-11.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'graffle'
+
+module GraphicalTestsForRails
+  
+  # A graphic order takes a Sheet in its constructor. The graphics
+  # method returns an array of AbstractGraphic objects that represents
+  # an ordered sequence of parts of a test.
+  #
+  # This abstract class only exists so there's a place to hang this comment.
+  class GraphicOrderer
+    def graphics; subclass_responsibility; end
+  end
+  
+  # (The following is much more obvious if you look at a sample document.)
+  # TODO: make an examples directory.
+  # 
+  # The sheet contains one or more _rivulets_ of ShapedGraphic objects connected
+  # with LineGraphic objects. All together, they're supposed to represent
+  # a user workflow. (The gap between one rivulet and the next typically 
+  # means that the user has gone away from the app, then returned.)
+  #
+  # graphics produces a concatenated array of the 
+  # rivulets (both the ShapedGraphic and LineGraphic objects). 
+  #
+  # Suppose there's more than one rivulet on the Sheet. graphics produces all
+  # the elements of the first, followed by all the elements of the second,
+  # etc. The first rivulet is the one _headed_ by the highest object on the
+  # page. After all of its elements have been placed in the graphics array,
+  # the next rivulet is headed by the highest remaining element on the Sheet.
+  #
+  # Within a single rivulet, location is irrelevant. All that matters is 
+  # where lines start and end.
+  #
+  # Notice that the head of the second rivulet may be higher than some
+  # element of the first. 
+  #
+  # A rivulet may have a single element.
+  
+  class InWorkflowOrder < GraphicOrderer
+    include Graffle
+    
+    def initialize(sheet)
+      @sheet = sheet
+    end
+    
+    def graphics()
+      @retval = []
+      @source = @sheet.graphics_without_labels.sort_by {|g| g.origin}
+      def @source.delete_this_id(graffle_id)
+        delete_if { |g| g.graffle_id == graffle_id }
+      end
+      
+      while (not @source.empty?)
+        something = @source.shift
+        @retval << something
+        trace_from_something(something)
+      end
+      @retval
+    end
+    
+    private
+    
+    def trace_from_something(something)
+      if something.behaves_like?(LineGraphic)
+        trace_from_line(something)
+      elsif something.behaves_like?(ShapedGraphic)
+        trace_from_shaped(something)
+      else
+        raise "Not supposed to do this with groups yet"
+      end
+    end
+    
+    def trace_from_line(line)
+      # Strictly, a line could connect to another line. How is that
+      # to be interpreted as a workflow, though?
+      shaped = line.to
+      if shaped
+        @retval << shaped
+        @source.delete_this_id(shaped.graffle_id)
+        trace_from_shaped(shaped)
+      end
+    end
+    
+    def trace_from_shaped(shaped)
+      line = @source.find do |g|
+        g.behaves_like?(LineGraphic) && g.from == shaped
+      end
+      if line
+        @retval << line
+        @source.delete_this_id(line.graffle_id)
+        trace_from_line(line)
+      end
+    end
+    
+  end
+end

data/test/graffle-file-types/opening-tests.rb

@@ -17,7 +17,6 @@ class TestOpeningOfDocuments < Test::Unit::TestCase
   def test_reading_of_plain_file
     document = Graffle.parse(relative("multiple-canvases.graffle"))
     assert_equal(3, document.sheets.length)
-#Å    pp document.sheets[0].graphics[0]
   end
   
   def test_reading_of_package

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

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-10.
+#  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 'graphical_tests_for_rails'
+
+
+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 line_graphic {
+        graffle_id_is 1
+      }
+      with shaped_graphic {
+        graffle_id_is 2
+        with_text "SIGNUP"
+      }
+    }
+    
+    [s.find_by_id(1), s.find_by_id(2)]
+  end
+  
+  def assert_commands_produced(expected, interpreter)
+    recorder = CommandRecorder.new
+    interpreter.run_against(recorder)
+    assert_equal(expected, recorder.record)
+  end
+  
+  def test_interpreter_applies_strategies
+    interpreter = GraphicInterpreter.new(two_graphics,
+            'line labels' => ArgsFromQuotedText.new,
+            'shaped graphic text' => TextIsNameOfPage.new('assert_on_page'))
+    assert_commands_produced(['produce("argument")', 'assert_on_page("signup")'],
+                             interpreter)                
+  end
+  
+  
+  def test_interpreter_can_omit_strategies
+    interpreter = GraphicInterpreter.new(two_graphics)
+    assert_commands_produced([], interpreter)
+  end
+
+  def assert_that_fails(page_name)
+    assert_equal('something that does not match', page_name)
+  end
+
+  def test_interpreter_annotates_test_failures_with_log
+    interpreter = GraphicInterpreter.new(two_graphics,
+            'shaped graphic text' => TextIsNameOfPage.new('assert_that_fails'))
+    interpreter.run_against(self)
+    flunk("Should be unreached.")
+  rescue Test::Unit::AssertionFailedError => e
+      assert_match(/\+ assert_that_fails\("signup"\)/, e.message)
+  end
+
+  def test_interpreter_annotates_test_errors_with_log
+    interpreter = GraphicInterpreter.new(two_graphics,
+            'line labels' => ArgsFromQuotedText.new)  # will generate nonexistent method
+    interpreter.run_against(self)
+    flunk("Should be unreached.")
+  rescue Exception => e
+      assert_match(/\+ produce\("argument"\)/, e.message)
+  end
+
+  def four_graphics_including_ellipses
+    s = sheet {
+      with line_label {  
+        for_line 1
+        with_text 'label'
+      }
+      with line_graphic {
+        graffle_id_is 1
+      }
+      with shaped_graphic {
+        graffle_id_is 2
+        with_text "signup "
+      }
+      with line_label {  
+        for_line 11
+        with_text 'waiting on a "friend"... '
+      }
+      with line_graphic {
+        graffle_id_is 11
+      }
+      with shaped_graphic {
+        graffle_id_is 22
+        with_text "time passes..."
+      }
+    }
+    
+    [1, 2, 11, 22].collect { |id| s.find_by_id(id) }
+  end
+  
+  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'),
+            'text...' => ArgsFromQuotedText.new)
+    assert_commands_produced(['line_here("label")', 'shape_here("signup")',
+                              'waiting_on_a("friend")', 'time_passes()'],
+                             interpreter)                
+  end
+  
+
+end