acts_as_flux_capacitor 0.6.2 → 0.6.3

data/History.txt

@@ -1,3 +1,8 @@
+== 0.6.3 2008-05-29
+
+* Removed Windoze newlines
+* converted tabs to spaces, per ruby standard
+
 == 0.6.2 2008-05-28
 
 * Exporting for windows newline removal

data/Rakefile

@@ -1,4 +1,4 @@
-require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
-
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
 Dir['tasks/**/*.rake'].each { |rake| load rake }

data/lib/acts_as_flux_capacitor/acts_as_flux_capacitor.rb

@@ -1,229 +1,231 @@
-module HolmesLabs #:nodoc:
-  module Acts #:nodoc:
-    module FluxCapacitor
-      module ActiveRecord #:nodoc:
-        def self.included(base) # :nodoc:
-	        base.extend ClassMethods
-        end
-				
-        module ClassMethods
-	        def acts_as_flux_capacitor
-						unless acts_as_flux_capacitor?
-							class << self
-								alias_method :original_find, :find
-							end
-						end
-						include Temporal
-	          include InstanceMethods
-            include OperateOnEvents
-            include OperateOnDurations
+module HolmesLabs #:nodoc:
+  module Acts #:nodoc:
+    module FluxCapacitor
+      module ActiveRecord #:nodoc:
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+        
+        module ClassMethods
+          def acts_as_flux_capacitor
+            unless acts_as_flux_capacitor?
+              class << self
+                alias_method :original_find, :find
+              end
+            end
+            include Temporal
+            include InstanceMethods
+            include OperateOnEvents
+            include OperateOnDurations
             include CompareEvents
-						include Validation
-	        end
-					
-					def flux_capacitor?
-						included_modules.include?(InstanceMethods)
-					end
-					alias acts_as_flux_capacitor? flux_capacitor?
-				end
+            include Validation
+          end
+          
+          def flux_capacitor?
+            included_modules.include?(InstanceMethods)
+          end
+          alias acts_as_flux_capacitor? flux_capacitor?
+        end
+        
+        protected
         
-				protected
-				
-        module InstanceMethods #:nodoc:
-          def self.included(base) # :nodoc:
+        module InstanceMethods #:nodoc:
+          def self.included(base) # :nodoc:
             base.extend ClassMethods
-            base.extend QueryGenerators
+            base.extend QueryGenerators
+          end
+          
+          module ClassMethods
+            
+            CUSTOM_FIND_OPTIONS = [
+              :before, # raw sql
+              :after, # raw sql
+              
+              :now,
+              :at,
+              
+              :past,
+              :present,
+              :future,
+              
+              :from,
+              :to,
+              
+              :starts_before, # raw sql
+              :ends_after # raw sql
+            ]
+            
+            def find(*args)
+              options = args.extract_options!
+              
+              current_time        = options.delete(:current_time) || Time.now
+              temporal_conditions = extract_temporal_conditions!(options)
+              sql_temporal        = sql_generate_temporal(temporal_conditions,current_time)
+              
+              with_scope( :find   => { 
+                          :conditions => sql_temporal , 
+                          :order      => sql_oldest_first }) do
+                original_find(*(args << options))
+              end
+            end
+            
+            def overlap(an_event,another_event)
+              an_event.to_range.overlap(another_event.to_range)
+            end
+            
+            def overlap?(an_event,another_event)
+              an_event.to_range.overlap?(another_event.to_range)
+            end
+            
+            private
+            
+            def extract_temporal_conditions!(options)
+              temporal_conditions = {}
+              
+              options.each do |key,val|
+                temporal_conditions.merge!({key, options.delete(key)}) if CUSTOM_FIND_OPTIONS.include?(key)
+              end
+              
+              temporal_conditions
+            end
+          end
+                      
+          module QueryGenerators
+          private
+            
+            def sql_before(some_time, current_time)
+              # table_name comes from ActiveRecord.
+              "#{table_name}.ends_at < '#{some_time.to_s(:db)}'"
+            end
+            alias sql_to sql_before
+            alias sql_ends_before sql_before
+            
+            def sql_after(some_time , current_time)
+              # table_name comes from ActiveRecord.
+              "#{table_name}.begins_at > '#{some_time.to_s(:db)}'"
+            end
+            alias sql_from sql_after
+            alias sql_begins_after sql_after
+            
+            def sql_at(some_time , current_time)
+              sql_join_conditions([ sql_starts_before(  some_time , current_time),
+                                    sql_ends_after(     some_time , current_time)])
+            end
+            
+            def sql_ends_after(some_time, current_time)
+              "#{table_name}.ends_at > '#{some_time.to_s(:db)}'"
+            end
+            
+            def sql_starts_before(some_time , current_time)
+              "#{table_name}.begins_at < '#{some_time.to_s(:db)}'"
+            end
+            
+            def sql_past(is_true , current_time)
+              if is_true
+                sql_before(current_time, current_time)
+              else
+                sql_join_conditions_or([  sql_present(  current_time),
+                                          sql_future(   current_time)])
+              end
+            end
+            alias sql_ended sql_past
+            
+            def sql_present(is_true , current_time)
+              if is_true
+                sql_at(current_time,current_time)
+              else
+                sql_join_conditions_or([  sql_past(   current_time),
+                                          sql_future( current_time)])
+              end
+            end
+            alias sql_now sql_present
+            
+            def sql_future(is_true, current_time)
+              if is_true
+                sql_after(current_time,current_time)
+              else
+                sql_join_conditions_or([  sql_present(current_time),
+                                          sql_past(     current_time)])
+              end
+            end
+            
+            def sql_oldest_first(attrib = :begins_at)
+              "#{table_name}.#{attrib.to_s} ASC"
+            end
+            
+            def sql_join_conditions(conditions)
+              "#{conditions.join(") AND (")}"
+            end
+            
+            def sql_join_conditions_or(conditions)
+              "#{conditions.join(") OR (")}"
+            end
+            
+            def sql_generate_temporal temporal_conditions , current_time
+              sql_conditions = []
+              temporal_conditions.each do |condition,parameter|
+                sql_conditions << send("sql_#{condition}".to_sym , parameter, current_time)
+              end
+              
+              sql_join_conditions(sql_conditions)
+            end
+          end
+          
+          def to_range
+            (start..finish)
           end
-					
-					module ClassMethods
-						
-						CUSTOM_FIND_OPTIONS = [
-							:before, # raw sql
-							:after, # raw sql
-							
-							:now,
-							:at,
-							
-							:past,
-							:present,
-							:future,
-							
-							:from,
-							:to,
-							
-							:starts_before, # raw sql
-							:ends_after # raw sql
-						]
-						
-						def find(*args)
-							options = args.extract_options!
-							
-							current_time				= options.delete(:current_time) || Time.now
-							temporal_conditions = extract_temporal_conditions!(options)
-							sql_temporal 				= sql_generate_temporal(temporal_conditions,current_time)
-							
-							with_scope(	:find 	=> { 
-													:conditions => sql_temporal , 
-													:order 			=> sql_oldest_first }) do
-								original_find(*(args << options))
-							end
-						end
-						
-						def overlap(an_event,another_event)
-							an_event.to_range.overlap(another_event.to_range)
-						end
-						
-						def overlap?(an_event,another_event)
-							an_event.to_range.overlap?(another_event.to_range)
-						end
-private
-						def extract_temporal_conditions!(options)
-							temporal_conditions = {}
-							
-							options.each do |key,val|
-								temporal_conditions.merge!({key, options.delete(key)}) if CUSTOM_FIND_OPTIONS.include?(key)
-							end
-							
-							temporal_conditions
-						end
-					end
-											
-					module QueryGenerators
-					private
-						
-						def sql_before(some_time, current_time)
-							# table_name comes from ActiveRecord.
-							"#{table_name}.ends_at < '#{some_time.to_s(:db)}'"
-						end
-						alias sql_to sql_before
-						alias sql_ends_before sql_before
-						
-						def sql_after(some_time , current_time)
-							# table_name comes from ActiveRecord.
-							"#{table_name}.begins_at > '#{some_time.to_s(:db)}'"
-						end
-						alias sql_from sql_after
-						alias sql_begins_after sql_after
-						
-						def sql_at(some_time , current_time)
-							sql_join_conditions([	sql_starts_before(	some_time , current_time),
-																		sql_ends_after(			some_time , current_time)])
-						end
-						
-						def sql_ends_after(some_time, current_time)
-							"#{table_name}.ends_at > '#{some_time.to_s(:db)}'"
-						end
-						
-						def sql_starts_before(some_time , current_time)
-							"#{table_name}.begins_at < '#{some_time.to_s(:db)}'"
-						end
-						
-						def sql_past(is_true , current_time)
-							if is_true
-								sql_before(current_time, current_time)
-							else
-								sql_join_conditions_or([	sql_present(	current_time),
-																					sql_future(		current_time)])
-							end
-						end
-						alias sql_ended sql_past
-						
-						def sql_present(is_true , current_time)
-							if is_true
-								sql_at(current_time,current_time)
-							else
-								sql_join_conditions_or([	sql_past(		current_time),
-																					sql_future(	current_time)])
-							end
-						end
-						alias sql_now sql_present
-						
-						def sql_future(is_true, current_time)
-							if is_true
-								sql_after(current_time,current_time)
-							else
-								sql_join_conditions_or([	sql_present(current_time),
-																					sql_past(			current_time)])
-							end
-						end
-						
-						def sql_oldest_first(attrib = :begins_at)
-							"#{table_name}.#{attrib.to_s} ASC"
-						end
-						
-						def sql_join_conditions(conditions)
-							"#{conditions.join(") AND (")}"
-						end
-						
-						def sql_join_conditions_or(conditions)
-							"#{conditions.join(") OR (")}"
-						end
-						
-						def sql_generate_temporal temporal_conditions , current_time
-							sql_conditions = []
-							temporal_conditions.each do |condition,parameter|
-								sql_conditions << send("sql_#{condition}".to_sym , parameter, current_time)
-							end
-							
-							sql_join_conditions(sql_conditions)
-						end
-					end
-					
-					def to_range
-						(start..finish)
-					end
-					alias range to_range
-					
-					def start ; read_attribute(:begins_at) ; end
-					def start=(val) ; write_attribute(:begins_at,val); end
-					
-					def finish ; read_attribute(:ends_at) ; end
-					def finish=(val) ; write_attribute(:ends_at,val) ; end
-					
-					alias start_time		start
-					alias start_time=		start=
-					alias beginning			start
-					alias beginning=		start=
-					alias end_time			finish
-					alias end_time=			finish=
-					alias from					start
-					alias from=					start=
-					alias to						finish
-					alias to=						finish=
-					alias ending				finish
-					alias ending=				finish=
-        end # InstanceMethods
-        
+          alias range to_range
+          
+          def start ; read_attribute(:begins_at) ; end
+          def start=(val) ; write_attribute(:begins_at,val); end
+          
+          def finish ; read_attribute(:ends_at) ; end
+          def finish=(val) ; write_attribute(:ends_at,val) ; end
+          
+          alias start_time    start
+          alias start_time=   start=
+          alias beginning     start
+          alias beginning=    start=
+          alias end_time      finish
+          alias end_time=     finish=
+          alias from          start
+          alias from=         start=
+          alias to            finish
+          alias to=           finish=
+          alias ending        finish
+          alias ending=       finish=
+        end # InstanceMethods
+        
         module OperateOnEvents
-					def at?(obj=Time.now)
-						bigger_than = self.start_time.before?(extract_time(obj,:start_time))   &&
-													self.end_time.after?(		extract_time(obj,:end_time 	))
-						smaller_than = 	self.start_time.after?( extract_time(obj,:start_time)) &&
-														self.end_time.before?(	extract_time(obj,:end_time))
-						same_size		= self.start_time == extract_time(obj,:start_time) &&
-													self.end_time		== extract_time(obj,:end_time)
-						return bigger_than || smaller_than || same_size
-					end
-					alias happening_at? at?
-					alias happened_at? at?
-					
-					def happening_now?(time = Time.now)
-						at?(time)
-					end
-					alias in_progress? 	happening_now?
-					alias now?					happening_now?
-					alias present?					happening_now?
-          
-          def started?(time = Time.now)
-            self.start_time.before?(time)
-          end
-          alias began? started?
-					
-					def ended?(time = Time.now)
-						self.end_time.before?(time)
-					end
-					alias finished? ended?
-					
+          def at?(obj=Time.now)
+            bigger_than = self.start_time.before?(extract_time(obj,:start_time))   &&
+                          self.end_time.after?(   extract_time(obj,:end_time  ))
+            smaller_than =  self.start_time.after?( extract_time(obj,:start_time)) &&
+                            self.end_time.before?(  extract_time(obj,:end_time))
+            same_size   = self.start_time == extract_time(obj,:start_time) &&
+                          self.end_time   == extract_time(obj,:end_time)
+            return bigger_than || smaller_than || same_size
+          end
+          alias happening_at? at?
+          alias happened_at? at?
+          
+          def happening_now?(time = Time.now)
+            at?(time)
+          end
+          alias in_progress?  happening_now?
+          alias now?          happening_now?
+          alias present?          happening_now?
+          
+          def started?(time = Time.now)
+            self.start_time.before?(time)
+          end
+          alias began? started?
+          
+          def ended?(time = Time.now)
+            self.end_time.before?(time)
+          end
+          alias finished? ended?
+          
           def <=>(obj)
             if self.before?(obj)
               return -1
@@ -235,94 +237,94 @@ private
               return 'ActsAsEvent: non-fatal error in #status'
             end
           end
-					
+          
           def transpose(duration)
             new_event = self.clone
-						new_event.transpose!(duration)
-          end
-          alias shift       transpose
-          alias reschedule  transpose
-          alias move        transpose
-					
-					def transpose!(duration)
-            self.beginning 	+= duration
-						self.ending			+= duration
-						return self
-          end
-          alias shift!       transpose!
-          alias reschedule!  transpose!
-          alias move!        transpose!
-        end # OperateOnEvents
-				
-        module OperateOnDurations
-          def elapsed(time = Time.now)
+            new_event.transpose!(duration)
+          end
+          alias shift       transpose
+          alias reschedule  transpose
+          alias move        transpose
+          
+          def transpose!(duration)
+            self.beginning  += duration
+            self.ending     += duration
+            return self
+          end
+          alias shift!       transpose!
+          alias reschedule!  transpose!
+          alias move!        transpose!
+        end # OperateOnEvents
+        
+        module OperateOnDurations
+          def elapsed(time = Time.now)
             time_since_beginning = self.class.length_of_time_since(self.beginning,time)
-						self.now?(time) ? time_since_beginning : nil
-          end
-          
-          def remaining(time = Time.now)
+            self.now?(time) ? time_since_beginning : nil
+          end
+          
+          def remaining(time = Time.now)
             time_until_end = self.class.length_of_time_until(self.ending,time)
-						self.now?(time) ? time_until_end : nil 
-          end
-          
+            self.now?(time) ? time_until_end : nil 
+          end
+          
           def percent_complete(time = Time.now)
-						amount_complete = self.elapsed(time)
-						amount_complete ? 100 * ((amount_complete * 1.0) / duration) : nil
-          end
-          alias percent_elapsed percent_complete
-          alias percent_finished percent_complete
-          
+            amount_complete = self.elapsed(time)
+            amount_complete ? 100 * ((amount_complete * 1.0) / duration) : nil
+          end
+          alias percent_elapsed percent_complete
+          alias percent_finished percent_complete
+          
           def percent_remaining(time = Time.now)
-						amount_remaining = self.remaining(time)
-						amount_remaining ? 100 * (( amount_remaining * 1.0) / duration) : nil 
-          end
-        end # OperateOnDurations
-				
-        module CompareEvents   
+            amount_remaining = self.remaining(time)
+            amount_remaining ? 100 * (( amount_remaining * 1.0) / duration) : nil 
+          end
+        end # OperateOnDurations
+        
+        module CompareEvents   
           def overlaps_with?(other_event)
-            self.to_range.overlaps?(other_event.to_range)
-          end
+            self.to_range.overlaps?(other_event.to_range)
+          end
+          
+          def overlap_with(other_event)
+            (self.to_range.overlap(other_event.to_range)).size
+          end
+          alias overlap overlap_with
           
-					def overlap_with(other_event)
-						(self.to_range.overlap(other_event.to_range)).size
-					end
-					alias overlap overlap_with
-					
           def back_to_back_with?(other_event,tolerance = 2.seconds)
-						# tolerance is in seconds.
-						self.start_time.before?(other_event.start_time) ? first_to_start = self : first_to_start = other_event
-						first_to_start.ends_at.approx_eql?(other_event.begins_at,tolerance)
+            # tolerance is in seconds.
+            self.start_time.before?(other_event.start_time) ? first_to_start = self : first_to_start = other_event
+            first_to_start.ends_at.approx_eql?(other_event.begins_at,tolerance)
+          end
+          
+          def duration
+            self.class.length_of_time_until(self.ending,self.beginning)
+          end
+          alias length_of_time  duration
+          alias length          duration
+          
+          def duration=(new_duration)
+            self.ending = self.beginning + new_duration
+          end
+          alias length_of_time= duration=
+          alias length=         duration=
+        end # CompareEvents
+        
+        module Validation
+          
+          def validate
+            if self.begins_at.nil?
+              errors.add(:begins_at, "must have a start time")
+              if self.ends_at.nil?
+                errors.add(:ends_at, "must have an end time")
+              end
+            else
+              self.beginning.after?(self.ending) ? errors.add_to_base("An event cannot end before it begins") : nil
+            end
           end
-					
-					def duration
-						self.class.length_of_time_until(self.ending,self.beginning)
-					end
-					alias length_of_time	duration
-					alias length				 	duration
-					
-					def duration=(new_duration)
-						self.ending = self.beginning + new_duration
-					end
-					alias length_of_time=	duration=
-					alias length=				 	duration=
-				end # CompareEvents
-				
-				module Validation
-					
-					def validate
-						if self.begins_at.nil?
-							errors.add(:begins_at, "must have a start time")
-							if self.ends_at.nil?
-								errors.add(:ends_at, "must have an end time")
-							end
-						else
-							self.beginning.after?(self.ending) ? errors.add_to_base("An event cannot end before it begins") : nil
-						end
-					end
-				end
-      end # ActiveRecord
-    end # FluxCapacitor
-  end # Acts
+        end
+      end # ActiveRecord
+    end # FluxCapacitor
+  end # Acts
 end # HolmesLabs
 ActiveRecord::Base.send :include, HolmesLabs::Acts::FluxCapacitor::ActiveRecord
 
@@ -332,9 +334,8 @@ ActiveRecord::Base.send :include, HolmesLabs::Acts::FluxCapacitor::ActiveRecord
 # force exclusivity of events at any given time via parameter to acts_as_event()
 # add new validations
 # rake tasks
-# parameter to comparison operator to still allow true if overlap
 
 
 # NOTES
 ###########
-# verify #find_* returns ordered results unless specified otherwise.
+# verify #find_* returns ordered results unless specified otherwise.

data/lib/acts_as_flux_capacitor/core_class_extensions.rb

@@ -1,18 +1,18 @@
 class Time
-	
-	@@approx_eql_tolerance_in_seconds = 2
-	
-	def Time.approx_eql_tolerance_in_seconds
-		@@approx_eql_tolerance_in_seconds
-	end
-	
-	def Time.approx_eql_tolerance_in_seconds=(seconds)
-		@@approx_eql_tolerance_in_seconds = seconds
-	end
-	
-	def approx_eql? other_time,tolerance = @@approx_eql_tolerance_in_seconds
-		times_to_i = [self,other_time].collect { |time| time.to_i }
-		(self - other_time).abs < tolerance
-	end
+  
+  @@approx_eql_tolerance_in_seconds = 2
+  
+  def Time.approx_eql_tolerance_in_seconds
+    @@approx_eql_tolerance_in_seconds
+  end
+  
+  def Time.approx_eql_tolerance_in_seconds=(seconds)
+    @@approx_eql_tolerance_in_seconds = seconds
+  end
+  
+  def approx_eql? other_time,tolerance = @@approx_eql_tolerance_in_seconds
+    times_to_i = [self,other_time].collect { |time| time.to_i }
+    (self - other_time).abs < tolerance
+  end
 end
 

data/lib/acts_as_flux_capacitor/range_overlap.rb

@@ -1,42 +1,42 @@
 class Range
-	
-	# the overlaps?(range) method comes from ActiveSupport::CoreExtensions::Range
-	# thanks to Nick Ang for suggesting its use.
-	# most of its tests were written by Jack Christensen of
-	# http://www.jackchristensen.com/article/2/detecting-overlapping-ranges
-  
-  # Returns true if ranges overlap, false otherwise
-  def overlaps? other
-		include?(other.first) || other.include?(first)
-	end
+  
+  # the overlaps?(range) method comes from ActiveSupport::CoreExtensions::Range
+  # thanks to Nick Ang for suggesting its use.
+  # most of its tests were written by Jack Christensen of
+  # http://www.jackchristensen.com/article/2/detecting-overlapping-ranges
+  
+  # Returns true if ranges overlap, false otherwise
+  def overlaps? other
+    include?(other.first) || other.include?(first)
+  end
 
-	# all of this added by jim cropcho:
+  # all of this added by jim cropcho:
 
-	def overlap(other_range)
-		return 0 unless self.overlaps?(other_range)
-		([self.first,other_range.first].max)..([self.last,other_range.last].min)
-	end
-	
-	def size
-		if self.first.is_a?(Time) && self.last.is_a?(Time)
-			time_size
-		elsif self.first.is_a?(Fixnum) || self.first.is_a?(Float) && 
-					self.last.is_a?(Fixnum)  || self.last.is_a?(Float)
-			number_size
-		else
-			raise "size cannot handle these object types."
-		end
-	end
-	alias length size
-	
+  def overlap(other_range)
+    return 0 unless self.overlaps?(other_range)
+    ([self.first,other_range.first].max)..([self.last,other_range.last].min)
+  end
+  
+  def size
+    if self.first.is_a?(Time) && self.last.is_a?(Time)
+      time_size
+    elsif self.first.is_a?(Fixnum) || self.first.is_a?(Float) && 
+          self.last.is_a?(Fixnum)  || self.last.is_a?(Float)
+      number_size
+    else
+      raise "size cannot handle these object types."
+    end
+  end
+  alias length size
+  
 private
-	
-	def time_size
-		raise "both endpoints of Range must be Time objects." unless self.last.is_a?(Time) && self.first.is_a?(Time)
-		return self.last-self.first
-	end
-	
-	def number_size # technically, off by infinity^(-1) when either or both endpoints are excluded. meh.
-		return self.last-self.first+1
-	end
+  
+  def time_size
+    raise "both endpoints of Range must be Time objects." unless self.last.is_a?(Time) && self.first.is_a?(Time)
+    return self.last-self.first
+  end
+  
+  def number_size # technically, off by infinity^(-1) when either or both endpoints are excluded. meh.
+    return self.last-self.first+1
+  end
 end

data/lib/acts_as_flux_capacitor/temporal.rb

@@ -4,124 +4,125 @@ module Temporal
     base.extend ClassMethods
     base.extend ClassAndInstanceMethods
   end
-	
-	module ClassMethods
-		def range_between(obj,another_obj)
-			first_obj,second_obj = ordered_tuple(obj,another_obj)
-			beginning = extract_time(first_obj,:ends_at)
-			ending    = extract_time(second_obj,:begins_at)
-			beginning.before?(ending) ? (beginning..ending).to_time : nil
-		end
-		
-		def period_between(obj,another_obj)
-			first_obj,second_obj = ordered_tuple(obj,another_obj)
-			beginning = extract_time(first_obj,:ends_at)
-			ending    = extract_time(second_obj,:begins_at)
-			beginning.before_or_at?(ending) ? ending - beginning : nil
-		end
-		
-		def length_of_time_until(obj,reference_obj=Time.now)
-			begins_at = extract_time(obj,:begins_at)
-			ends_at = extract_time(obj,:ends_at)
-			reference_point = extract_time(reference_obj,:ends_at)
-			
-			time_until_begins = begins_at - reference_point
-			# has not started
-			if time_until_begins >= 0
-				time_until_begins
-			# has started, but not ended
-			elsif time_until_begins < 0 && reference_point.before?(ends_at)
-				0
-			# has ended
-			else
-				nil
-			end
-		end
-		
-		def length_of_time_since(obj,reference_obj=Time.now)
-			begins_at = extract_time(obj,:begins_at)
-			ends_at = extract_time(obj,:ends_at)
-			
-			reference_point = extract_time(reference_obj,:begins_at)
+  
+  module ClassMethods
+    def range_between(obj,another_obj)
+      first_obj,second_obj = ordered_tuple(obj,another_obj)
+      beginning = extract_time(first_obj,:ends_at)
+      ending    = extract_time(second_obj,:begins_at)
+      beginning.before?(ending) ? (beginning..ending).to_time : nil
+    end
+    
+    def period_between(obj,another_obj)
+      first_obj,second_obj = ordered_tuple(obj,another_obj)
+      beginning = extract_time(first_obj,:ends_at)
+      ending    = extract_time(second_obj,:begins_at)
+      beginning.before_or_at?(ending) ? ending - beginning : nil
+    end
+    
+    def length_of_time_until(obj,reference_obj=Time.now)
+      begins_at = extract_time(obj,:begins_at)
+      ends_at = extract_time(obj,:ends_at)
+      reference_point = extract_time(reference_obj,:ends_at)
+      
+      time_until_begins = begins_at - reference_point
+      # has not started
+      if time_until_begins >= 0
+        time_until_begins
+      # has started, but not ended
+      elsif time_until_begins < 0 && reference_point.before?(ends_at)
+        0
+      # has ended
+      else
+        nil
+      end
+    end
+    
+    def length_of_time_since(obj,reference_obj=Time.now)
+      begins_at = extract_time(obj,:begins_at)
+      ends_at = extract_time(obj,:ends_at)
+      
+      reference_point = extract_time(reference_obj,:begins_at)
 
-			time_since_ended = reference_point - ends_at
-			has_started_but_not_ended = time_since_ended <= 0 && reference_point.after?(begins_at)
-			has_ended = time_since_ended >= 0
-			if has_ended
-				time_since_ended
-			elsif has_started_but_not_ended
-				0
-			else # has not started
-				nil
-			end
-		end
-	end
-	
-	module ClassAndInstanceMethods
+      time_since_ended = reference_point - ends_at
+      has_started_but_not_ended = time_since_ended <= 0 && reference_point.after?(begins_at)
+      has_ended = time_since_ended >= 0
+      if has_ended
+        time_since_ended
+      elsif has_started_but_not_ended
+        0
+      else # has not started
+        nil
+      end
+    end
+  end
+  
+  module ClassAndInstanceMethods
 
-	private
-		def ordered_tuple(an_obj,other_obj)
-			if an_obj.before?(other_obj)
-				return an_obj,other_obj
-			else
-				return other_obj,an_obj
-			end
-		end
-		
-		def extract_time(obj,accessor)
-			# if object possesses accessor method, return obj.accessor.
-			# if not, return object. This is useful for fudging duck typing-
-			# style interaction between Events and Times/Dates, etc.
-			obj.respond_to?(accessor.to_sym) ? obj.send(accessor.to_sym) : obj
-		end
-	end
-	
-	module InstanceMethods
-		
-		def self.included(base) # :nodoc:
+    private
+  
+    def ordered_tuple(an_obj,other_obj)
+      if an_obj.before?(other_obj)
+        return an_obj,other_obj
+      else
+        return other_obj,an_obj
+      end
+    end
+    
+    def extract_time(obj,accessor)
+      # if object possesses accessor method, return obj.accessor.
+      # if not, return object. This is useful for fudging duck typing-
+      # style interaction between Events and Times/Dates, etc.
+      obj.respond_to?(accessor.to_sym) ? obj.send(accessor.to_sym) : obj
+    end
+  end
+  
+  module InstanceMethods
+    
+    def self.included(base) # :nodoc:
       base.extend ClassMethods
-		end
-		
-		def before?(obj)
-			extract_time(self,:ends_at) < extract_time(obj,:begins_at)
-		end
-		
-		def before_or_at? obj
-			extract_time(self,:ends_at) <= extract_time(obj,:begins_at)
-		end
-		
-		def after?(obj)
-			extract_time(self,:begins_at) > extract_time(obj,:ends_at)
-		end
-		
-		def after_or_at? obj
-			extract_time(self,:ends_at) <= extract_time(obj,:begins_at)
-		end
-		
-		def between? obj,another_obj
-			first_obj,second_obj = ordered_tuple(obj,another_obj)
-			beginning_between = extract_time(first_obj,:ends_at)
-			ending_between    = extract_time(second_obj,:begins_at)
-			
-			self.start_time.after_or_at?(beginning_between) && 
-			self.end_time.before_or_at?(ending_between)
-		end
+    end
+    
+    def before?(obj)
+      extract_time(self,:ends_at) < extract_time(obj,:begins_at)
+    end
+    
+    def before_or_at? obj
+      extract_time(self,:ends_at) <= extract_time(obj,:begins_at)
+    end
+    
+    def after?(obj)
+      extract_time(self,:begins_at) > extract_time(obj,:ends_at)
+    end
+    
+    def after_or_at? obj
+      extract_time(self,:ends_at) <= extract_time(obj,:begins_at)
+    end
+    
+    def between? obj,another_obj
+      first_obj,second_obj = ordered_tuple(obj,another_obj)
+      beginning_between = extract_time(first_obj,:ends_at)
+      ending_between    = extract_time(second_obj,:begins_at)
+      
+      self.start_time.after_or_at?(beginning_between) && 
+      self.end_time.before_or_at?(ending_between)
+    end
     
     def in_the_future?(time = Time.now)
-			extract_time(self,:begins_at).after?(time)
+      extract_time(self,:begins_at).after?(time)
     end
-		alias future? in_the_future?
-		
-		def in_the_past?(time=Time.now)
-			extract_time(self,:ends_at).before?(time)
-		end
-		alias past? in_the_past?
-	end
+    alias future? in_the_future?
+    
+    def in_the_past?(time=Time.now)
+      extract_time(self,:ends_at).before?(time)
+    end
+    alias past? in_the_past?
+  end
 
-protected
-	
-	include InstanceMethods
-	include ClassAndInstanceMethods
+  protected
+  
+  include InstanceMethods
+  include ClassAndInstanceMethods
 end
 
 [Time,Date,DateTime].each { |klass| klass.send :include , Temporal }

data/lib/acts_as_flux_capacitor/version.rb

@@ -1,11 +1,11 @@
-module HolmesLabs #:nodoc:
-  module Acts #:nodoc:
-    module FluxCapacitor
+module HolmesLabs #:nodoc:
+  module Acts #:nodoc:
+    module FluxCapacitor
       module VERSION #:nodoc:
         
         MAJOR = 0
         MINOR = 6
-        TINY  = 2
+        TINY  = 3
 
         STRING = [MAJOR, MINOR, TINY].join('.')
         

data/spec/report.html

@@ -296,7 +296,7 @@ a {
     <dd class="spec passed"><span class="passed_spec_name">should determine if two times are approximately equal (tolerance @ 0.1 seconds)</span></dd>
   </dl>
 </div>
-<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>0.476378 seconds</strong>";</script>
+<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>0.38148 seconds</strong>";</script>
 <script type="text/javascript">document.getElementById('totals').innerHTML = "40 examples, 0 failures";</script>
 </div>
 </div>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_flux_capacitor
 version: !ruby/object:Gem::Version 
-  version: 0.6.2
+  version: 0.6.3
 platform: ruby
 authors: 
 - Jim Cropcho
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-28 00:00:00 -04:00
+date: 2008-05-29 00:00:00 -04:00
 default_executable: 
 dependencies: []