acts_as_flux_capacitor 0.6.3 → 0.6.4

data/Manifest.txt

@@ -7,9 +7,13 @@ Rakefile
 config/hoe.rb
 config/requirements.rb
 lib/acts_as_flux_capacitor.rb
-lib/acts_as_flux_capacitor/acts_as_flux_capacitor.rb
+lib/acts_as_flux_capacitor/base.rb
+lib/acts_as_flux_capacitor/sql.rb
+lib/acts_as_flux_capacitor/compare_events.rb
+lib/acts_as_flux_capacitor/operate_on_events.rb
+lib/acts_as_flux_capacitor/operate_on_durations.rb
 lib/acts_as_flux_capacitor/core_class_extensions.rb
-lib/acts_as_flux_capacitor/range_overlap.rb
+lib/acts_as_flux_capacitor/validation.rb
 lib/acts_as_flux_capacitor/temporal.rb
 lib/acts_as_flux_capacitor/version.rb
 script/console

data/config/hoe.rb

@@ -8,7 +8,7 @@ RUBYFORGE_PROJECT = 'aafc' # The unix name for your project
 HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
 DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
 EXTRA_DEPENDENCIES = [
-#  ['activesupport', '>= 1.3.1']
+  ['activerecord'   , '>= 1.2.0']
 ]    # An array of rubygem dependencies [name, version]
 
 @config_file = "~/.rubyforge/user-config.yml"

data/lib/acts_as_flux_capacitor/base.rb

@@ -0,0 +1,129 @@
+module HolmesLabs::Acts::FluxCapacitor::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
+  
+  protected
+  
+  module InstanceMethods #:nodoc:
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+      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
+    
+    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
+end
+
+ActiveRecord::Base.send :include, HolmesLabs::Acts::FluxCapacitor::ActiveRecord
+
+# TODO
+###########
+# allow events to be created by start time and duration
+# force exclusivity of events at any given time via parameter to acts_as_event()
+# add new validations
+# rake tasks
+
+
+# NOTES
+###########
+# verify #find_* returns ordered results unless specified otherwise.

data/lib/acts_as_flux_capacitor/compare_events.rb

@@ -0,0 +1,29 @@
+module HolmesLabs::Acts::FluxCapacitor::ActiveRecord::CompareEvents   
+  def overlaps_with?(other_event)
+    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 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)
+  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
+

data/lib/acts_as_flux_capacitor/core_class_extensions.rb

@@ -16,3 +16,45 @@ class Time
   end
 end
 
+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
+
+  # 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
+  
+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
+end

data/lib/acts_as_flux_capacitor/operate_on_durations.rb

@@ -0,0 +1,23 @@
+module HolmesLabs::Acts::FluxCapacitor::ActiveRecord::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)
+    time_until_end = self.class.length_of_time_until(self.ending,time)
+    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
+  
+  def percent_remaining(time = Time.now)
+    amount_remaining = self.remaining(time)
+    amount_remaining ? 100 * (( amount_remaining * 1.0) / duration) : nil 
+  end
+end

data/lib/acts_as_flux_capacitor/operate_on_events.rb

@@ -0,0 +1,60 @@
+module HolmesLabs::Acts::FluxCapacitor::ActiveRecord::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 <=>(obj)
+    if self.before?(obj)
+      return -1
+    elsif at?(obj)
+      return 0
+    elsif self.after?(obj)
+      return 1
+    else
+      return 'acts_as_flux_capacitor: non-fatal error in #<=>'
+    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
+

data/lib/acts_as_flux_capacitor/sql.rb

@@ -0,0 +1,81 @@
+module HolmesLabs::Acts::FluxCapacitor::ActiveRecord::InstanceMethods::QueryGenerators #:nodoc:
+
+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

data/lib/acts_as_flux_capacitor/validation.rb

@@ -0,0 +1,13 @@
+module HolmesLabs::Acts::FluxCapacitor::ActiveRecord::Validation #:nodoc:
+          
+  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

data/lib/acts_as_flux_capacitor/version.rb

@@ -5,7 +5,7 @@ module HolmesLabs #:nodoc:
         
         MAJOR = 0
         MINOR = 6
-        TINY  = 3
+        TINY  = 4
 
         STRING = [MAJOR, MINOR, TINY].join('.')
         

data/lib/acts_as_flux_capacitor.rb

@@ -1,12 +1,11 @@
-SUBDIRECTORY = *['lib','acts_as_flux_capacitor']
-
-require 'rubygems'
-require 'activerecord'
-require 'date'
-
-require File.join(SUBDIRECTORY, 'version')
-require File.join(SUBDIRECTORY, 'temporal')
-require File.join(SUBDIRECTORY, 'range_overlap')
-require File.join(SUBDIRECTORY, 'core_class_extensions')
-require File.join(SUBDIRECTORY, 'acts_as_flux_capacitor')
+LIB_DIRECTORY = *['lib','acts_as_flux_capacitor']
 
+require File.join(LIB_DIRECTORY, 'version')
+require File.join(LIB_DIRECTORY, 'temporal')
+require File.join(LIB_DIRECTORY, 'core_class_extensions')
+require File.join(LIB_DIRECTORY, 'base')
+require File.join(LIB_DIRECTORY, 'sql')
+require File.join(LIB_DIRECTORY, 'validation')
+require File.join(LIB_DIRECTORY, 'operate_on_events')
+require File.join(LIB_DIRECTORY, 'operate_on_durations')
+require File.join(LIB_DIRECTORY, 'compare_events')

data/spec/report.html

@@ -289,14 +289,19 @@ a {
 </div>
 <div class="example_group">
   <dl>
-  <dt id="example_group_8">The extensions to the Time class</dt>
+  <dt id="example_group_8">The extensions to</dt>
+  </dl>
+</div>
+<div class="example_group">
+  <dl>
+  <dt id="example_group_9">The extensions to the Time class</dt>
     <script type="text/javascript">moveProgressBar('97.5');</script>
     <dd class="spec passed"><span class="passed_spec_name">should determine if two times are approximately equal (tolerance @ 1 second)</span></dd>
     <script type="text/javascript">moveProgressBar('100.0');</script>
     <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.38148 seconds</strong>";</script>
+<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>0.424051 seconds</strong>";</script>
 <script type="text/javascript">document.getElementById('totals').innerHTML = "40 examples, 0 failures";</script>
 </div>
 </div>

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>acts_as_flux_capacitor</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/acts_as_flux_capacitor"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/acts_as_flux_capacitor" class="numbers">0.5.2</a>
+      <a href="http://rubyforge.org/projects/acts_as_flux_capacitor" class="numbers">0.6.4</a>
     </div>
     <h1>&#x2192; &#8216;acts_as_flux_capacitor&#8217;</h1>
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_flux_capacitor
 version: !ruby/object:Gem::Version 
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors: 
 - Jim Cropcho
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-29 00:00:00 -04:00
+date: 2008-07-11 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
 description: Acts as Flux Capacitor is a better way to work with time-centric ActiveRecord models. Make it feel good to manipulate objects representing real-world events and/or objects with a finite period of database persistence!
 email: 
 - jim.cropcho@gmail.com
@@ -37,9 +46,13 @@ files:
 - config/hoe.rb
 - config/requirements.rb
 - lib/acts_as_flux_capacitor.rb
-- lib/acts_as_flux_capacitor/acts_as_flux_capacitor.rb
+- lib/acts_as_flux_capacitor/base.rb
+- lib/acts_as_flux_capacitor/sql.rb
+- lib/acts_as_flux_capacitor/compare_events.rb
+- lib/acts_as_flux_capacitor/operate_on_events.rb
+- lib/acts_as_flux_capacitor/operate_on_durations.rb
 - lib/acts_as_flux_capacitor/core_class_extensions.rb
-- lib/acts_as_flux_capacitor/range_overlap.rb
+- lib/acts_as_flux_capacitor/validation.rb
 - lib/acts_as_flux_capacitor/temporal.rb
 - lib/acts_as_flux_capacitor/version.rb
 - script/console
@@ -88,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: aafc
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Acts as Flux Capacitor is a better way to work with time-centric ActiveRecord models. Make it feel good to manipulate objects representing real-world events and/or objects with a finite period of database persistence!

data/lib/acts_as_flux_capacitor/acts_as_flux_capacitor.rb

@@ -1,341 +0,0 @@
-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
-        
-        protected
-        
-        module InstanceMethods #:nodoc:
-          def self.included(base) # :nodoc:
-            base.extend ClassMethods
-            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
-          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 <=>(obj)
-            if self.before?(obj)
-              return -1
-            elsif at?(obj)
-              return 0
-            elsif self.after?(obj)
-              return 1
-            else
-              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)
-            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)
-            time_until_end = self.class.length_of_time_until(self.ending,time)
-            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
-          
-          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   
-          def overlaps_with?(other_event)
-            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 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)
-          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 # HolmesLabs
-ActiveRecord::Base.send :include, HolmesLabs::Acts::FluxCapacitor::ActiveRecord
-
-# TODO
-###########
-# allow events to be created by start time and duration
-# force exclusivity of events at any given time via parameter to acts_as_event()
-# add new validations
-# rake tasks
-
-
-# NOTES
-###########
-# verify #find_* returns ordered results unless specified otherwise.

data/lib/acts_as_flux_capacitor/range_overlap.rb

@@ -1,42 +0,0 @@
-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
-
-  # 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
-  
-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
-end