affirmit 3.1.4.1.5.9.2.6.5.3.5.8.9.7.9.3.2

data/LICENSE

@@ -0,0 +1 @@
+GROUP HUG! Unicorns! Seriously, did you think that we would license this?  Go, use, and spread the love.

data/README.md

@@ -0,0 +1,13 @@
+AffirmIt 
+========
+
+AffirmIt is the supportive testing framework for Ruby.  For more information, please see [our web site](http://affirmit.org/).
+
+Quotes from Dr. Sue Donim
+---------
+
+* "...a study done in 2010, a gedanken experiment, revealed that the number one issue facing software developers and software itself is self-esteem [footnote: 80% of statistics are made up.]..."
+* "insecure, low-confidence, low-self-esteem code results in tentative systems that are not capable of the kind of robust operation we need..."
+* "We need systems that have the creative confidence to take the bold, innovative steps we need them to take; to instill confidence in end users.  If this approach is extended from back to front, end users will feel good about the softer outcomes of their inept..." 
+* "...countless generations of incompetent people have shown us that you don?t actually need success to feel successful..."
+* "...in a world where perception is reality, what we need most is our people and our users to feel successful..."

data/lib/affirmit.rb

@@ -0,0 +1,12 @@
+require 'affirmit/commandline'
+
+##
+# AffirmIt, the application affirmation framework.
+module AffirmIt
+end
+
+at_exit do
+  if $!.nil? and not AffirmIt::CommandLine.started?
+    AffirmIt::CommandLine.run
+  end
+end

data/lib/affirmit/affirmation.rb

@@ -0,0 +1,120 @@
+require 'affirmit/esteem'
+require 'affirmit/grouphug'
+
+module AffirmIt
+  class Affirmation
+    include Esteem
+    
+    ##
+    # These issues are not raised to the facilitator by #embrace.
+    # Recycled from Test::Unit.
+    PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, Interrupt, SystemExit]
+    
+    attr_reader :method_name
+    
+    def initialize(method_name)
+      # Ruby syntax note: If we don't put the parentheses here,
+      # it calls the super's initialize method with all the
+      # parameters supplied to this method.  However,
+      # Esteem.initialize takes no parameters, so I have to
+      # explicitly pass it no parameters.
+      super()
+      @method_name = method_name
+    end
+    
+    class << self
+      
+      ##
+      # Collects all the individual affirmations in this class
+      # into a big group hug.
+      def group_hug
+        group_hug = GroupHug.new(name) # name = class name
+        public_instance_methods(true).sort.each do |method_name|
+          if method_name =~ /^affirm[^A-Za-z0-9]/
+            group_hug << new(method_name)
+          end
+        end
+        group_hug
+      end
+      
+    end
+    
+    ##
+    # Affirmations may want to build themselves up before they
+    # are embraced by a facilitator.  If so, they should inherit
+    # and more fully define the build_up method.
+    def build_up
+    end
+    
+    ##
+    # After being embraced, whether their opinions are preferred
+    # by the facilitator or not, affirmations should take care
+    # of their environment and recycle any resources that they
+    # have consumed when building themselves up.  In order to do
+    # so, they should inherit and define the recycle method.
+    def recycle
+    end
+    
+    def affirmation_count
+      1
+    end
+    
+    def name
+      "#{self.class.name}.#{@method_name}"
+    end
+    
+    def add_preference
+      @facilitator.add_preference
+    end
+    
+    def add_bonus_point
+      @facilitator.add_bonus_point
+    end
+    
+    def praise object, msg = ''
+      @facilitator.praise "What a wonderful #{object}!  #{msg}"
+    end
+    
+    def embrace facilitator
+      @facilitator = facilitator
+      success = false
+      facilitator.with_arms_around self do
+        begin
+          build_up
+          __send__ @method_name
+          success = true
+        rescue DifferingOpinion => opinion
+          facilitator.espouse_differing_opinion opinion
+        rescue ElectiveDeferral => deferral
+          facilitator.defer_success deferral
+        rescue IntolerantPig => pig
+          facilitator.expel pig
+        rescue BehavioralChallenge => challenge
+          facilitator.admit_challenge challenge
+        rescue Exception => e
+          raise e if PASSTHROUGH_EXCEPTIONS.include? e.class
+          facilitator.raise_issue e
+        ensure
+          begin
+            recycle
+            facilitator.cherish_affirmation if success
+          rescue DifferingOpinion => opinion
+            facilitator.espouse_differing_opinion opinion
+          rescue ElectiveDeferral => deferral
+            facilitator.defer_success deferral
+          rescue IntolerantPig => pig
+            facilitator.expel pig
+          rescue BehavioralChallenge => challenge
+            facilitator.admit_challenge challenge
+          rescue Exception => e
+            raise e if PASSTHROUGH_EXCEPTIONS.include? e.class
+            facilitator.raise_issue e
+          end
+        end
+      end
+      
+      facilitator.add_affirmation
+      @facilitator = nil
+    end
+  end
+end

data/lib/affirmit/commandline.rb

@@ -0,0 +1,34 @@
+require 'affirmit/affirmation'
+require 'affirmit/facilitator'
+require 'affirmit/grouphug'
+require 'affirmit/rosecoloredglasses'
+require 'affirmit/ui/consoleui'
+
+module AffirmIt
+  class CommandLine
+    
+    class << self
+      def started?
+        @started or false
+      end
+      
+      def do_not_start_automatically
+        @started = true
+      end
+      
+      def run(args=ARGV, group_hug_name=$0)
+        do_not_start_automatically
+        affirmation_classes = []
+        ::ObjectSpace.each_object(Class) do |c|
+          affirmation_classes << c if c < Affirmation
+        end
+        group_hug = GroupHug.new(group_hug_name)
+        affirmation_classes.sort.each { |c| group_hug << c.group_hug }
+        
+        ui = AffirmIt::UI::ConsoleUI.new
+        Facilitator.new(ui).embrace group_hug
+      end
+      
+    end
+  end
+end

data/lib/affirmit/defaultframeofreference.rb

@@ -0,0 +1,10 @@
+module AffirmIt
+	##
+	# Our default frame of reference accepts boolean truth for what
+	# it is.  Unless, of course, it's not.
+	class DefaultFrameOfReference 
+		def is_true(something)
+			something == true
+		end
+  end
+end

data/lib/affirmit/esteem.rb

@@ -0,0 +1,141 @@
+require 'affirmit/defaultframeofreference'
+require 'affirmit/preferences'
+
+module AffirmIt
+	
+	##
+	# This is a raise-able class to denote circumstances
+	# in which the code being affirmed behaves in
+	# an unexpected way.  This is typically the case
+	# with high-sprited or strong-willed code.  It
+	# could be a problem, but we prefer to medicate
+	# where possible.
+	class BehavioralChallenge < Exception; end
+
+	##
+	# Please note carefully that although this class
+	# derives eventually from Exception, it does so 
+	# solely so that it can be raised as a noteworthy
+	# condition.  It is not to be negatively construed as
+	# an error in any way.
+	class DifferingOpinion < BehavioralChallenge; end
+	
+	##
+	# This raise-able class is used to indicate the
+	# condition when an affirmation elects to defer
+	# success explicitly. See defer_success method.
+	class ElectiveDeferral < Exception; end
+
+	##
+	# This is reserved exclusively for the assert_ methods.
+	class IntolerantPig < Exception; end
+
+	##
+	# Mixin for adding esteem to your class.
+	# Your class achieves good self-esteem by
+	# calling the methods of this class.
+	module Esteem
+    include Preferences
+    
+    DEFAULT_PREFERENCE = AffirmIt::Preference::Is.new true
+
+		##
+		# Since we're embracing relativism, what is true
+		# depends entirely on your frame of reference.
+		# This class will provide a default frame, but
+		# if it does not suit your needs -- i.e., if it
+		# fails to result in sufficiently high
+		# self-esteem -- you might consider changing
+		# your frame of reference.
+		attr_accessor :frame_of_reference
+		
+		def initialize
+			@frame_of_reference = DefaultFrameOfReference.new
+		end
+
+		def maybe(something) 
+			if @frame_of_reference.is_true(something) then
+				add_bonus_point
+			end
+		end
+
+    ##
+    # Prefers that a certain value agrees with your
+    # preference, thus:
+    #
+    # prefer_that (2 + 2), is(5)
+    # prefer_that [:lisp], ((includes :infix_operators) & ~(includes :parentheses)) | (is [:ruby])
+		def prefer_that actual, preference = DEFAULT_PREFERENCE, msg = ''
+      add_preference
+      unless @frame_of_reference.is_true(preference.is_preferred? actual)
+        raise DifferingOpinion, "Preferred #{preference.description}, got <#{actual}>. #{msg}"
+      end
+		end
+    
+    ##
+    # Classes that wish to note the existence of preferences
+    # may override this method accordingly.
+    def add_preference
+    end
+		
+    ##
+    # Classes that wish to track bonus points may override
+    # this method accordingly.
+    def add_bonus_point
+    end
+		
+    ##
+    # Every object needs a little encouragement sometimes.
+    # Subclasses should make sure that this praise is passed
+    # on to the facilitator.
+    def praise object, msg = "Great job!"
+		end
+
+		##
+		# This method is used to indicate a preference toward
+		# exceptions in certain cases.
+		def prefer_raise expected
+      add_preference
+      begin
+				yield
+			rescue Exception => ex
+				raise BehavioralChallenge.new("expected #{expected}, got #{ex.class}") unless ex.is_a?(expected)
+        return ex
+      else
+  			raise BehavioralChallenge.new("We really preferred to receive an exception of type #{expected}") unless exception
+	  	end
+		end
+
+    def prefer_no_raise
+      add_preference
+      begin
+        yield
+      rescue Exception => ex
+        raise BehavioralChallenge.new("We were not expecting a raise, but we got #{ex.class}")
+      end
+    end
+
+		##
+		# Use this method when you want to explicitly and immediately
+		# defer success of the affirmation.  This is analogous to the
+		# Test::Unit flunk method.  Of course, that kind of attitude
+		# is not tolerated here.
+		def defer_success msg = 'Success deferred'
+			raise ElectiveDeferral.new msg
+		end
+
+  	def method_missing name, *args, &block
+			# Some programmers will fall back to their old habits of
+			# "asserting" whether something is "true" or "false".
+			# We must stand firm against this sort of thinking and
+			# redirect them to the preferred path.
+			if name =~ /^assert_.*/ then
+				msg = "Who are you to say what's true?  Please use prefer_ methods using a suitable frame of reference.  Geeze, you probably hate puppies too."
+				raise IntolerantPig.new(msg)
+			else
+				super name, *args, &block
+			end
+		end
+
+	end
+end

data/lib/affirmit/event/affirmationevent.rb

@@ -0,0 +1,12 @@
+require 'affirmit/event/event'
+
+module AffirmIt
+  class AffirmationEvent < Event
+    attr_reader :affirmation
+    
+    def initialize type, affirmation
+      super type
+      @affirmation = affirmation
+    end
+  end
+end

data/lib/affirmit/event/event.rb

@@ -0,0 +1,30 @@
+module AffirmIt
+  class Event
+    EVENT_TYPE_DESCRIPTIONS = {
+      :embrace_started => "Embrace started",
+      :embrace_ended => "Embrace ended",
+      :arms_wrapped_around => "Arms wrapped around an affirmation",
+      :arms_disentangled_from => "Arms disentangled from an affirmation",
+      :affirmation_cherished => "Affirmation cherished",
+      :affirmation_added => "Affirmation added",
+      :preference_added => "Preference added",
+      :bonus_point_added => "Bonus point added",
+      :praise => "Praise",
+      :success_deferred => "Success deferred",
+      :differing_opinion_encountered => "Differing opinion encountered",
+      :behavioral_challenge_admitted => "Behavioral challenge admitted",
+      :issue_raised => "Issue raised",
+      :pig_expelled => "Intolerant pig expelled"
+    }
+    
+    attr_reader :type
+    
+    def initialize type
+      @type = type
+    end
+    
+    def description
+      EVENT_TYPE_DESCRIPTIONS[@type]
+    end
+  end
+end

data/lib/affirmit/event/issueevent.rb

@@ -0,0 +1,16 @@
+require 'affirmit/event/event'
+
+module AffirmIt
+  class IssueEvent < Event
+    attr_reader :issue
+    
+    def initialize type, issue
+      super type
+      @issue = issue
+    end
+    
+    def backtrace
+      @issue.backtrace.reject { |line| line =~ /^.*lib\/affirmit.*:/ }
+    end
+  end
+end

data/lib/affirmit/event/praiseevent.rb

@@ -0,0 +1,12 @@
+require 'affirmit/event/event'
+
+module AffirmIt
+  class PraiseEvent < Event
+    attr_reader :message
+    
+    def initialize type, message
+      super type
+      @message = message
+    end
+  end
+end

data/lib/affirmit/facilitator.rb

@@ -0,0 +1,172 @@
+require 'affirmit/esteem'
+require 'affirmit/event/affirmationevent'
+require 'affirmit/event/event'
+require 'affirmit/event/issueevent'
+require 'affirmit/event/praiseevent'
+require 'affirmit/facilitatorlistener'
+
+module AffirmIt
+  
+  ##
+  # A facilitator embraces affirmations and notifies any
+  # interested classes of behavioral challenges encountered
+  # with the affirmed code.  This class is similar to a
+  # "test runner" in less sensitive behavioral evaluation
+  # frameworks.
+  class Facilitator
+    
+    attr_accessor :listener
+    attr_reader :affirmation_count, :cherished_affirmation_count,
+      :preference_count, :bonus_points, :events
+    
+    def initialize(listener)
+      @affirmation_count = 0
+      @cherished_affirmation_count = 0
+      @preference_count = 0
+      @bonus_points = 0
+      @events = []
+      @listener = listener
+    end
+    
+    ##
+    # Embraces the given affirmation, noting any challenges
+    # encountered therein.  Intolerant pigs will be
+    # expelled immediately.
+    def embrace affirmation
+      @listener.notify self, AffirmationEvent.new(:embrace_started, affirmation)
+      affirmation.embrace self
+      @listener.notify self, AffirmationEvent.new(:embrace_ended, affirmation)
+    end
+    
+    ##
+    # Wraps the given affirmation in its arms, ensuring
+    # that any interested parties are notified that the
+    # facilitator's arms are being wrapped around, and
+    # disentangled from, the given affirmation.
+    def with_arms_around affirmation
+      @listener.notify self, AffirmationEvent.new(:arms_wrapped_around, affirmation)
+      begin
+        yield
+      ensure
+        @listener.notify self, AffirmationEvent.new(:arms_disentangled_from, affirmation)
+      end
+    end
+    
+    def cherish_affirmation
+      @cherished_affirmation_count += 1
+      @listener.notify self, Event.new(:affirmation_cherished)
+    end
+    
+    ##
+    # Registers that an individual affirmation has been
+    # embraced -- not a group hug.
+    def add_affirmation
+      @affirmation_count += 1
+      @listener.notify self, Event.new(:affirmation_added)
+    end
+    
+    ##
+    # Registers that an affirmation has a certain preference;
+    # whether the preference is "true" or "false" in our
+    # particular, subjective frame of reference does not
+    # matter.
+    def add_preference
+      @preference_count += 1
+      @listener.notify self, Event.new(:preference_added)
+    end
+    
+    ##
+    # Adds another bonus point to the affirmation's embrace.
+    # If you get enough bonus points, it can make up for any
+    # differing opinions you may have!
+    def add_bonus_point
+      @bonus_points += 1
+      @listener.notify self, Event.new(:bonus_point_added)
+    end
+    
+    ##
+    # Lavish praise with the given message.
+    def praise message
+      add_event PraiseEvent.new(:praise, message)
+    end
+    
+    ##
+    # A facilitator may defer the success of an affirmation,
+    # cherishing it until it may be praised in fullness.
+    def defer_success deferral
+      add_event IssueEvent.new(:success_deferred, deferral)
+    end
+    
+    ##
+    # Facilitators may espouse differing opinions.  This is
+    # not something so banal as an "failure", of course, since
+    # all opinions are completely valid in their own special
+    # ways.
+    def espouse_differing_opinion opinion
+      add_event IssueEvent.new(:differing_opinion_encountered, opinion)
+    end
+    
+    ##
+    # Some affirmations may present challenges that the
+    # facilitator will note.
+    def admit_challenge challenge
+      add_event IssueEvent.new(:behavioral_challenge_admitted, challenge)
+    end
+    
+    ##
+    # Attempting to embrace an affirmation may at times raise
+    # unexpected issues, noted here.
+    def raise_issue exception
+      add_event IssueEvent.new(:issue_raised, exception)
+    end
+    
+    ##
+    # Intolerant pigs will not be tolerated by a facilitator
+    # and will be expelled immediately.
+    def expel pig
+      @listener.notify self, IssueEvent.new(:pig_expelled, pig)
+      Kernel.exit 3
+    end
+    
+    def behavioral_challenge_count
+      count_events :behavioral_challenge_admitted
+    end
+    
+    def differing_opinion_count
+      count_events :differing_opinion_encountered
+    end
+    
+    def deferred_success_count
+      count_events :success_deferred
+    end
+    
+    def issue_count
+      count_events :issue_raised
+    end
+    
+    ##
+    # The number of stars, from 3.0 to 5.0.  We don't want to
+    # hurt anybody's feelings by giving them less than 3!
+    def stars
+      if @affirmation_count == 0 then
+        5.0
+      else
+        non_cherished_affirmations = @affirmation_count - @cherished_affirmation_count - @bonus_points
+        if non_cherished_affirmations <= 0
+          5.0
+        else
+          5.0 - ((non_cherished_affirmations) * 2.0 / @affirmation_count.to_f)
+        end
+      end
+    end
+    
+    def add_event event
+      @events << event
+      @listener.notify self, @events.last
+    end
+    
+    def count_events type
+      @events.count { |event| event.type == type }
+    end
+  end
+end

data/lib/affirmit/facilitatorlistener.rb

@@ -0,0 +1,6 @@
+module AffirmIt
+  module FacilitatorListener
+    def notify facilitator, event
+    end
+  end
+end

data/lib/affirmit/grouphug.rb

@@ -0,0 +1,76 @@
+require 'affirmit/defaultframeofreference'
+
+module AffirmIt
+  
+  ##
+  # A group hug is a collection of affirmations (or other
+  # group hugs) that a Facilitator can embrace together.
+  class GroupHug
+    attr_reader :name
+    
+    def initialize(name)
+      @affirmations = []
+      @name = name
+    end
+    
+    ##
+    # Sets a frame of reference for all the affirmations in
+    # this group hug.
+    def frame_of_reference= frame_of_reference
+      @affirmations.each do |affirmation|
+        affirmation.frame_of_reference = frame_of_reference
+      end
+    end
+    
+    ##
+    # Not to be called directly.  When a facilitator embraces
+    # a group hug (or affirmation), the group hug or
+    # affirmation embraces the facilitator reciprocally.
+    def embrace facilitator
+      facilitator.with_arms_around self do
+        @affirmations.each do |affirmation|
+          affirmation.embrace facilitator
+        end
+      end
+    end
+    
+    def << affirmation
+      @affirmations << affirmation
+    end
+    
+    def [] index
+      @affirmations[index]
+    end
+    
+    def each
+      @affirmations.each { |affirmation| yield affirmation }
+    end
+    
+    def each_affirmation &block
+      @affirmations.each do |affirmation|
+        if affirmation.is_a? GroupHug then
+          affirmation.each_affirmation &block
+        else
+          block.call affirmation
+        end
+      end
+    end
+    
+    def size
+      @affirmations.size
+    end
+    
+    ##
+    # Returns the number of individual affirmations in this
+    # group hug, recursively.
+    def affirmation_count
+      @affirmations.inject(0) do |sum, affirmation|
+        sum + affirmation.affirmation_count
+      end
+    end
+    
+    def to_s
+      "Group hug #{name} with #{affirmation_count} affirmations"
+    end
+  end
+end

data/lib/affirmit/preference/and.rb

@@ -0,0 +1,22 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class And < AffirmIt::Preference::Preference
+      def initialize *preferences
+        @preferences = preferences
+      end
+      
+      def is_preferred? actual
+        @preferences.each do |preference|
+          return false if not preference.is_preferred? actual
+        end
+        return true
+      end
+      
+      def description
+        return @preferences.collect { |preference| preference.description }.join ' and '
+      end
+    end
+  end
+end

data/lib/affirmit/preference/between.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class Between < AffirmIt::Preference::Preference
+      def initialize min, max
+        @min, @max = min, max
+      end
+      
+      def is_preferred? actual
+        actual >= @min and actual <= @max
+      end
+      
+      def description
+        return "between <#{@min.inspect}> and <#{@max.inspect}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/greaterthan.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class GreaterThan < AffirmIt::Preference::Preference
+      def initialize expected
+        @expected = expected
+      end
+      
+      def is_preferred? actual
+        actual > @expected
+      end
+      
+      def description
+        return "greater than <#{@expected.inspect}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/includes.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class Includes < AffirmIt::Preference::Preference
+      def initialize expected
+        @expected = expected
+      end
+      
+      def is_preferred? actual
+        actual.include? @expected
+      end
+      
+      def description
+        return "an object that includes <#{@expected.inspect}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/is.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class Is < AffirmIt::Preference::Preference
+      def initialize expected
+        @expected = expected
+      end
+      
+      def is_preferred? actual
+        actual == @expected
+      end
+      
+      def description
+        return "<#{@expected.inspect}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/isa.rb

@@ -0,0 +1,21 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class IsA < AffirmIt::Preference::Preference
+      def initialize expected
+        @expected = expected
+      end
+      
+      def is_preferred? actual
+        actual.is_a? @expected
+      end
+      
+      def description
+        class_name = @expected.inspect
+        article = if class_name =~ /^[AEIOUaeiou]/ then 'an' else 'a' end
+        return "object that is #{article} <#{class_name}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/lessthan.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class LessThan < AffirmIt::Preference::Preference
+      def initialize expected
+        @expected = expected
+      end
+      
+      def is_preferred? actual
+        actual < @expected
+      end
+      
+      def description
+        return "less than <#{@expected.inspect}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/matches.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class Matches < AffirmIt::Preference::Preference
+      def initialize expected
+        @expected = expected
+      end
+      
+      def is_preferred? actual
+        actual =~ @expected
+      end
+      
+      def description
+        return "a match for <#{@expected.inspect}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/not.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class Not < AffirmIt::Preference::Preference
+      def initialize preference
+        @preference = preference
+      end
+      
+      def is_preferred? actual
+        not (@preference.is_preferred? actual)
+      end
+      
+      def description
+        return "not #{@preference.description}"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/or.rb

@@ -0,0 +1,22 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class Or < AffirmIt::Preference::Preference
+      def initialize *preferences
+        @preferences = preferences
+      end
+      
+      def is_preferred? actual
+        @preferences.each do |preference|
+          return true if preference.is_preferred? actual
+        end
+        return false
+      end
+      
+      def description
+        return @preferences.collect { |preference| preference.description }.join ' or '
+      end
+    end
+  end
+end

data/lib/affirmit/preference/preference.rb

@@ -0,0 +1,30 @@
+module AffirmIt
+  module Preference
+    
+    ##
+    # A Preference is a condition that can be preferred by an
+    # affirmation.  The code being affirmed may choose to prefer
+    # the same opinion or not.  If the two opinions differ, the
+    # facilitator will make note of the differing opinion with
+    # the description returned by this preference.
+    class Preference
+      ##
+      # Determines whether the actual value agrees with this
+      # preference.
+      def is_preferred? actual
+        return true
+      end
+      
+      ##
+      # If #is_preferred? returns false, this method will be
+      # called in order to generate a description of this
+      # preference, in an overall description like:
+      #
+      # "preferred description, but was <actual>"
+      def description
+        return ''
+      end
+    end
+    
+  end
+end

data/lib/affirmit/preference/respondsto.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class RespondsTo < AffirmIt::Preference::Preference
+      def initialize expected
+        @expected = expected
+      end
+      
+      def is_preferred? actual
+        actual.respond_to? @expected
+      end
+      
+      def description
+        return "an object that responds to <#{@expected.inspect}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preference/sameas.rb

@@ -0,0 +1,19 @@
+require 'affirmit/preference/preference'
+
+module AffirmIt
+  module Preference
+    class SameAs < AffirmIt::Preference::Preference
+      def initialize expected
+        @expected = expected
+      end
+      
+      def is_preferred? actual
+        actual.equal? @expected
+      end
+      
+      def description
+        return "same as <#{@expected.inspect}>"
+      end
+    end
+  end
+end

data/lib/affirmit/preferences.rb

@@ -0,0 +1,107 @@
+require 'affirmit/preference/and'
+require 'affirmit/preference/between'
+require 'affirmit/preference/greaterthan'
+require 'affirmit/preference/includes'
+require 'affirmit/preference/is'
+require 'affirmit/preference/isa'
+require 'affirmit/preference/lessthan'
+require 'affirmit/preference/matches'
+require 'affirmit/preference/not'
+require 'affirmit/preference/or'
+require 'affirmit/preference/preference'
+require 'affirmit/preference/respondsto'
+require 'affirmit/preference/sameas'
+
+module AffirmIt
+  ##
+  # The Preferences module includes DSL-like methods
+  # to help affirmations express their preferences.
+  #
+  # For example:
+  #
+  # is(5)
+  # between(4, 6)
+  # (greater_than 3) & (less_than 7)
+  # (is a String) | (is a Fixnum)
+  module Preferences
+    def a(preferred_class)
+      AffirmIt::Preference::IsA.new preferred_class
+    end
+    
+    def an(preferred_class)
+      AffirmIt::Preference::IsA.new preferred_class
+    end
+    
+    def between(min, max)
+      AffirmIt::Preference::Between.new min, max
+    end
+    
+    def equals(preferred)
+      AffirmIt::Preference::Is.new preferred
+    end
+    
+    def greater_than(preferred)
+      AffirmIt::Preference::GreaterThan.new preferred
+    end
+    
+    def includes(preferred)
+      AffirmIt::Preference::Includes.new preferred
+    end
+    
+    ##
+    # If we have learned anything from
+    # lawyer-politicians, it is that everything
+    # depends on your definition of "is"....
+    #
+    # In this case, the "is" method helps with
+    # legibility of affirmations.  Feel free to
+    # re-implement with your preferred discourse on
+    # being.  We're certain you'll do a great job!
+    def is(preferred)
+      if preferred.is_a? AffirmIt::Preference::Preference
+        preferred
+      else
+        AffirmIt::Preference::Is.new preferred
+      end
+    end
+    
+    def isnt(preferred)
+      ~is(preferred)
+    end
+    
+    def less_than(preferred)
+      AffirmIt::Preference::LessThan.new preferred
+    end
+    
+    def matches(preferred_regexp)
+      AffirmIt::Preference::Matches.new preferred_regexp
+    end
+    
+    def responds_to(preferred_message)
+      AffirmIt::Preference::RespondsTo.new preferred_message
+    end
+    
+    def same_as(preferred)
+      AffirmIt::Preference::SameAs.new preferred
+    end
+  end
+  
+  ##
+  # Add &, | and ~ methods (instead of and, or and not,
+  # which we cannot redefine) to combine Preferences.
+  module Preference
+    class Preference
+      def & other
+        return And.new self, other
+      end
+      
+      def | other
+        return Or.new self, other
+      end
+      
+      def ~
+        return Not.new self
+      end
+    end
+  end
+end

data/lib/affirmit/rosecoloredglasses.rb

@@ -0,0 +1,10 @@
+module AffirmIt
+  ##
+  # If you're feeling as if nothing can go wrong, then maybe
+  # your frame of reference should be RoseColoredGlasses!
+  class RoseColoredClasses
+    def is_true(something)
+      true
+    end
+  end
+end

data/lib/affirmit/ui/consoleui.rb

@@ -0,0 +1,73 @@
+require 'affirmit/event/affirmationevent'
+require 'affirmit/event/event'
+require 'affirmit/event/issueevent'
+require 'affirmit/event/praiseevent'
+require 'affirmit/facilitator'
+require 'affirmit/facilitatorlistener'
+
+module AffirmIt
+  module UI
+    class ConsoleUI
+      include FacilitatorListener
+      
+      attr_reader :output
+      
+      def initialize(output = STDOUT)
+        @output = output
+      end
+      
+      def notify facilitator, event
+        case event.type
+        when :embrace_started
+          @output.puts "Starting group hug #{event.affirmation.name}"
+        when :affirmation_cherished
+          @output.print '.'
+        when :success_deferred
+          @output.print 'D'
+        when :differing_opinion_encountered
+          @output.print 'O'
+        when :behavioral_challenge_admitted
+          @output.print 'B'
+        when :issue_raised
+          @output.print 'I'
+        when :pig_expelled
+          @output.print '!'
+          @output.puts ''
+          @output.puts args[0].message
+        when :embrace_ended
+          @output.puts ''
+          write_summary facilitator
+          write_challenges facilitator
+        end
+      end
+      
+      def write_summary facilitator
+        @output.puts "There were:"
+        @output.puts "  - #{facilitator.affirmation_count} affirmations (#{facilitator.cherished_affirmation_count} cherished)"
+        @output.puts "  - #{facilitator.preference_count} preferences"
+        @output.puts "  - #{facilitator.differing_opinion_count} differing opinions"
+        @output.puts "  - #{facilitator.deferred_success_count} elective success deferrals"
+        @output.puts "  - #{facilitator.behavioral_challenge_count} behavioral challenges"
+        @output.puts "  - #{facilitator.issue_count} issues"
+        @output.puts "  - #{facilitator.bonus_points} bonus points"
+        @output.puts ''
+        @output.puts "You got #{facilitator.stars.round} out of 5 gold stars!  Great job!"
+      end
+      
+      def write_challenges facilitator
+        facilitator.events.each do |event|
+          if event.is_a? IssueEvent
+            @output.puts ''
+            @output.puts "#{event.description}: #{event.issue.message}"
+            event.backtrace.each do |line|
+              @output.puts line
+            end
+          elsif event.is_a? PraiseEvent
+            @output.puts ''
+            @output.puts "#{event.description}: #{event.message}"
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: affirmit
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 3.1.4.1.5.9.2.6.5.3.5.8.9.7.9.3.2
+platform: ruby
+authors: 
+  - Eric Galluzzo
+  - Eric Kenny
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-30 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: AffirmIt! is the supportive testing framework for Ruby..
+email: 
+  - affirmit@affirmit.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - lib/affirmit.rb
+  - lib/affirmit/affirmation.rb
+  - lib/affirmit/commandline.rb
+  - lib/affirmit/defaultframeofreference.rb
+  - lib/affirmit/esteem.rb
+  - lib/affirmit/facilitator.rb
+  - lib/affirmit/facilitatorlistener.rb
+  - lib/affirmit/grouphug.rb
+  - lib/affirmit/preferences.rb
+  - lib/affirmit/rosecoloredglasses.rb
+  - lib/affirmit/event/affirmationevent.rb
+  - lib/affirmit/event/event.rb
+  - lib/affirmit/event/issueevent.rb
+  - lib/affirmit/event/praiseevent.rb
+  - lib/affirmit/preference/and.rb
+  - lib/affirmit/preference/between.rb
+  - lib/affirmit/preference/greaterthan.rb
+  - lib/affirmit/preference/includes.rb
+  - lib/affirmit/preference/is.rb
+  - lib/affirmit/preference/isa.rb
+  - lib/affirmit/preference/lessthan.rb
+  - lib/affirmit/preference/matches.rb
+  - lib/affirmit/preference/not.rb
+  - lib/affirmit/preference/or.rb
+  - lib/affirmit/preference/preference.rb
+  - lib/affirmit/preference/respondsto.rb
+  - lib/affirmit/preference/sameas.rb
+  - lib/affirmit/ui/consoleui.rb
+  - LICENSE
+  - README.md
+has_rdoc: true
+homepage: http://affirmit.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.6
+requirements: []
+
+rubyforge_project: affirmit
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: AffirmIt! is the supportive testing framework for Ruby.
+test_files: []
+