graffle 0.1.8 → 0.1.9

data/lib/graffle.rb

@@ -19,17 +19,34 @@ require 'graffle/point'
 module Graffle
   
   # Parse the given data and stereotype the result. Returns an object
-  # stereotyped as Graffle::Document.
+  # stereotyped as Graffle::Document. Deprecated in favor of 
+  # Parse.parse_file and Parse.parse_xml.
+  
   def self.parse(filename_or_xml)
+    puts "Graffle.parse is deprecated in favor of Graffle.parse_file or Graffle.parse_xml."
     if File.directory?(filename_or_xml)
       filename_or_xml = File.join(filename_or_xml, "data.plist")
     end
-    
+
     prog1(Plist.parse_xml(filename_or_xml)) do | doc |
       Document.takes_on(doc)
     end
   end
 
+  def self.parse_file(filename)
+    if File.directory?(filename)
+      filename = File.join(filename, "data.plist")
+    end
+
+    parse_xml(File.read(filename))
+  end
+  
+  def self.parse_xml(content)
+    prog1(Plist.parse_xml(content)) do | doc |
+      Document.takes_on(doc)
+    end
+  end
+
   def self.stereotype(o)        # :nodoc:
     return true if ShapedGraphic.takes_on(o)
     return true if LineGraphic.takes_on(o)

data/lib/graffle/point.rb

@@ -22,8 +22,7 @@ module Graffle
       elsif args[0] =~ /\{(.*),\s(.*)\}/
         initialize(Float($1), Float($2))
       else
-        # TODO: this should be user_is_bewildered(msg = "how could this point be reached?")
-        user_disputes("this point can be reached") { "unreachable?"}
+        user_is_bewildered
       end
     end
     

data/lib/graffle/stereotypes.rb

@@ -6,16 +6,16 @@
 module Graffle
   module Builders # :nodoc: 
     def self.raw(mod, basic_structure = {}, &block)
-      g = basic_structure.dup
-      g.behave_like(mod)
-      g.instance_eval(&block) if block
-      g
+      prog1(basic_structure.dup) do | g |
+        g.behave_like(mod)
+        g.instance_eval(&block) if block
+      end
     end
     
     def self.classed(mod, basic_structure = {}, &block)
-      g = raw(mod, basic_structure, &block)
-      g['Class'] = mod.basename
-      g
+      prog1(raw(mod, basic_structure, &block)) do | g | 
+        g['Class'] = mod.basename
+      end
     end
     
     def abstract_graphic(&block)
@@ -57,21 +57,28 @@ module Graffle
       }
     end
     
+    def annotation(string)
+      prog1(string) { | s | s.behave_like(Graffle::Note) }
+    end
+    
   end
   
   
-  # TODO: rename AbstractGraphic Nestable
+  # TODO: Can groups have notes of their own? Putting notes behavior
+  # in AbstractGraphic assumes they can.
   
   # Behavior that's common to all visible objects, be they lines,
   # rectangles, text objects, etc.
   module AbstractGraphic
     include Comparable
-    
+    include Builders    
+
     # TODO: I'm not wild about the way this both checks if something's
     # possible and also does it. Separate in caller?
     def self.takes_on(o, mod) # :nodoc: 
       if graffle_class_matches?(o, mod)
         o.behave_like(mod)
+        o.notes.behave_like(Note) if o.has_notes?
         return true
       end
     end
@@ -103,6 +110,28 @@ module Graffle
     # A Point. Must be defined in the whatever includes this module.
     def origin; includer_responsibility; end
     
+    # OmniGraffle Pro objects can have _notes_ attached to them.
+    # A note is just an RTF string. If there is no note, the return 
+    # value is a null object that responds to as_lines with an empty
+    # array.
+    def notes
+      if has_key?('Notes')
+        self['Notes']
+      else
+        Text::Null.new
+      end
+    end
+    alias_method :note, :notes
+    
+    def with_notes(string) # :nodoc: 
+      self['Notes'] = annotation(string)
+    end
+    alias_method :with_note, :with_notes
+    
+    # Does this object contain a note? (Notes are an OmniGraffle
+    # Pro feature)
+    def has_note?; self.has_key?('Notes'); end
+    alias_method :has_notes?, :has_note?
     
     
   end
@@ -144,8 +173,8 @@ module Graffle
 
     # If this is a graffle document with an implicit single 
     # sheet, make it explicit.
-    # TODO: Check that OmniGraffle non-pro can read such a doc. Probably 
-    # more needs to go along with the GraphicsList.
+    # MISSING: This destroys the structure of the file, so it 
+    # should not now be written.
     def make_sure_has_sheets # :nodoc: 
       splice_in_single_sheet unless self.has_key?('Sheets')
       self
@@ -237,7 +266,7 @@ module Graffle
     end
     alias_method :contents, :content
     
-    def with_text(string)  # :nodoc:
+    def with_content(string)  # :nodoc:
       self['Text'] = text(string)
     end
   end
@@ -274,6 +303,11 @@ module Graffle
       end
     end
     
+    # true if the line has a label. false otherwise.
+    def has_label?
+      not (not label)  # Here is a gesture in honor of Scheme.
+    end
+    
     # Almost certainly, what you care about is the Text of the label, which
     # you could get like this:
     #   line.label.content 
@@ -323,7 +357,7 @@ module Graffle
       container.find_by_id(endpoint['ID'])
     end
   
-    # TODO: note this is no good for updating, since fields other than
+    # MISSING: note this is no good for updating, since fields other than
     # ID may be destroyed.
     def _link__bemhack(type, thing)
       id = thing.respond_to?(:graffle_id) ? thing.graffle_id : thing
@@ -335,7 +369,7 @@ module Graffle
   # Behavior common to Sheet and Group, both of which contain an array
   # of AbstractGraphic.
   # :stopdoc: 
-  # TODO: perhaps some cleverness with Enumerator would be in order?
+  # MISSING: perhaps some cleverness with Enumerator would be in order?
   # :startdoc:
   module Container
 
@@ -368,7 +402,8 @@ module Graffle
         if Graffle.stereotype(child)
           child.container = parent
         else
-          puts "TODO: can not yet stereotype child with id #{child['ID'].inspect} and class #{child['Class'].inspect}."
+          puts "Can not yet stereotype child with id #{child['ID'].inspect} and class #{child['Class'].inspect}."
+          puts "Most likely there's been no call for it yet. So call for it."
           pp child.keys
         end
       end
@@ -460,11 +495,22 @@ module Graffle
       StyledTextReader.new(self.as_rtf).as_lines
     end
     
-    class Null  # Null object for text
+    # Null object for text
+    class Null # :nodoc:
       def as_lines; []; end
     end
     
   end
   
+  # Access to the RTF in an object's note.
+  module Note
+    include Text
+    # The RTF itself.
+    def as_rtf
+      self
+    end
+    
+  end
+  
   
 end

data/lib/graffle/version.rb

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

data/lib/graphical_tests_for_rails.rb

@@ -4,22 +4,25 @@
 #  Copyright (c) 2007. All rights reserved.
 
 
-
 require 'graffle'
-require 'graphical_tests_for_rails/interpreters'
 require 'graphical_tests_for_rails/orderings'
+require 'graphical_tests_for_rails/text-appliers'
+require 'graphical_tests_for_rails/picture-appliers'
+require 'graphical_tests_for_rails/graphic-volunteers'
+require 'graphical_tests_for_rails/volunteer-pool'
 
 # 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
+#   AbstractTextApplier objects 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 
+#   style of test. For example, an InWorkflowOrder represents an 
 #   order created by tracing through shapes connected by lines.
 
 module GraphicalTestsForRails
-  
+  include GraphicArrayOrderings
+  include TextAppliers
 end

data/lib/graphical_tests_for_rails/graphic-volunteers.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-07-20.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'enumerator'
+require 'test/unit/assertionfailederror'
+require 'graphical_tests_for_rails/text-appliers'
+
+module GraphicalTestsForRails
+  
+  class AbstractGraphicVolunteer # :nodoc:
+    
+    attr_accessor :text_applier
+    
+    def initialize(name)
+      @name = name
+      @matcher = @lines_extractor = @text_applier = nil
+    end
+    
+    def do_nothing_defaults
+      @matcher = proc { | object | true }
+      @lines_extractor = proc { |object| [] }
+      @text_applier = TextAppliers::TextApplierThatDoesNothing.new
+    end
+
+    def likes?(object); 
+      @matcher.call(object)
+    end
+
+    def extract_lines(object)
+      @lines_extractor.call(object)
+    end
+    
+    def apply(graphic, target)
+      @text_applier.apply(extract_lines(graphic), target)
+    end
+
+  end
+
+  class EagerButUselessVolunteer < AbstractGraphicVolunteer # :nodoc:
+    def initialize
+      super('do-nothing graphic applier')
+      do_nothing_defaults
+    end
+  end
+  
+
+  # A GraphicVolunteer knows how to match and apply one particular
+  # kind of graphic (such as 'line label content'). These are normally 
+  # invisible to users. See design-notes/graphical-tests-for-rails-objects.graffle
+  # for a picture of class collaborations.
+  class GraphicVolunteer < AbstractGraphicVolunteer
+    attr_writer :next
+    
+    def initialize(name); 
+      super(name)
+      do_nothing_defaults
+      @next = EagerButUselessVolunteer.new
+    end
+        
+    def handles(&block); @matcher = block; self; end
+    def and_extracts(&block); @lines_extractor = block; self; end
+    
+    def likes?(object)
+      if super(object)
+        next_object = @lines_extractor.call(object)
+        @next.likes?(next_object)
+      end
+    end
+  end    
+  
+
+  
+end

data/lib/graphical_tests_for_rails/orderings.rb

@@ -5,97 +5,103 @@
 
 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
+
+  # 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 GraphicArrayOrderings
+    # A graphic order takes a Graffle::Sheet in its constructor. The graphics
+    # method returns an array of Graffle::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
-    
-    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)
+
+    # (The following is much more obvious if you look at a sample document.)
+    # 
+    # The sheet contains one or more _rivulets_ of Graffle::ShapedGraphic objects connected
+    # with Graffle::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 Graffle::ShapedGraphic and Graffle::LineGraphic objects). 
+    #
+    # Suppose there's more than one rivulet on the Graffle::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 Graffle::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
-      @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"
+
+      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
-    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)
+
+      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
-    end
-    
-    def trace_from_shaped(shaped)
-      line = @source.find do |g|
-        g.behaves_like?(LineGraphic) && g.from == shaped
+
+      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
-      if line
-        @retval << line
-        @source.delete_this_id(line.graffle_id)
-        trace_from_line(line)
+
+      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
+
 end