acts_as_span 0.0.5

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+rdoc
+pkg

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in acts_as_span.gemspec
+gemspec
+
+gem 'rspec'
+gem 'acts_as_fu'

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    acts_as_span (0.0.5)
+      activerecord (>= 3)
+      activesupport
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.10)
+      activesupport (= 3.0.10)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.10)
+      activemodel (= 3.0.10)
+      activesupport (= 3.0.10)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.10)
+    acts_as_fu (0.0.7.2)
+      activerecord
+      sqlite3-ruby
+    arel (2.0.10)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    sqlite3 (1.3.4)
+    sqlite3-ruby (1.3.3)
+      sqlite3 (>= 1.3.3)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  acts_as_fu
+  acts_as_span!
+  rspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2011 Annkissam
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,33 @@
+= acts_as_span
+
+ActiveRecord model w/ a start_date and an end_date
+
+== Getting Started
+
+In your Gemfile:
+
+    gem "acts_as_span"
+
+In your model:
+
+    class SpanRecord < ActiveRecord::Base
+      acts_as_span
+    end
+
+In your migrations:
+
+    class AddSpanToSpanRecord < ActiveRecord::Migration
+      def self.up
+        add_column :span_records, :start_date, :date
+        add_column :span_records, :end_date, :date
+      end
+
+      def self.down
+        remove_column :span_records, :start_date
+        remove_column :span_records, :end_date
+      end
+    end
+
+== Copyright
+
+Copyright (c) 2011 Annkissam. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')

data/acts_as_span.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "acts_as_span/version"
+
+Gem::Specification.new do |s|
+  s.name        = "acts_as_span"
+  s.version     = ActsAsSpan::VERSION::STRING
+  s.authors     = ["Eric Sullivan"]
+  s.email       = ["eric.sullivan@annkissam.com"]
+  s.homepage    = "https://github.com/annkissam/acts_as_span"
+  s.summary     = ActsAsSpan::VERSION::SUMMARY
+  s.description = %q{start_date and end_date as a span w/ ActiveRecord}
+
+  s.rubyforge_project = "acts_as_span"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency(%q<activerecord>, [">= 3"])
+  s.add_dependency('activesupport')
+end

data/lib/acts_as_span.rb

@@ -0,0 +1,161 @@
+require 'active_support'
+require 'ostruct'
+require 'forwardable'
+
+ACTS_AS_SPAN_PATH = File.dirname(__FILE__) + "/acts_as_span/"
+
+require ACTS_AS_SPAN_PATH + 'version'
+require ACTS_AS_SPAN_PATH + 'span_klass'
+require ACTS_AS_SPAN_PATH + 'span_instance'
+
+module ActsAsSpan
+  extend ActiveSupport::Concern
+  
+  class << self
+    def options
+      @options ||= {
+        :start_date_field => :start_date,
+        :end_date_field => :end_date,
+        :start_date_field_required => false,
+        :end_date_field_required => false,
+        :span_overlap_scope => nil,
+        :span_overlap_count => nil,
+        :name => :default
+      }
+    end
+    
+    def configure
+      yield(self) if block_given?
+    end
+  end
+  
+  #by default, all model classess & their instances will return false w/ acts_as_span?
+  included do
+    self.send(:extend, ActsAsSpan::NegativeMethods)
+    self.send(:include, ActsAsSpan::NegativeMethods)
+  end
+  
+  module ClassMethods
+    def acts_as_span(*args)
+      #this model & its instances will return true w/ acts_as_span?
+      self.send(:extend, ActsAsSpan::PositiveMethods)
+      self.send(:include, ActsAsSpan::PositiveMethods)
+      
+      self.send(:extend, Forwardable)
+      
+      self.send(:extend, ActsAsSpan::ExtendedClassMethods)
+      self.send(:include, ActsAsSpan::IncludedInstanceMethods)
+      
+      options = OpenStruct.new(args.last.is_a?(Hash) ? ActsAsSpan.options.merge(args.pop) : ActsAsSpan.options)
+      
+      #if span_overlap_scope is specified the span_overlap_count defaults to 0
+      options.span_overlap_count ||= 0 if options.span_overlap_scope
+      
+      acts_as_span_definitions[options.name] = options
+      
+      def_delegators :span, :close!,
+                            :close_on!,
+                            :span_status,
+                            :span_status_on,
+                            :span_status_to_s,
+                            :span_status_to_s_on,
+                            :current?,
+                            :current_on?,
+                            :future?,
+                            :future_on?,
+                            :expired?,
+                            :expired_on?
+                            
+      def_delegators 'self.class', :acts_as_span_definitions
+      
+      class << self
+        self.send(:extend, Forwardable)
+        
+        def_delegators :span, :current,
+                              :current_on,
+                              :future,
+                              :future_on,
+                              :expired,
+                              :expired_on
+      end
+      
+      validate :validate_spans
+    end
+    
+    def acts_as_span_definitions
+      @_acts_as_span_definitions ||= {}
+    end
+  end
+  
+  module ExtendedClassMethods
+    def overlap(test_record)
+      overlap_for(test_record, :default, :default)
+    end
+    
+    def overlap_for(test_record, test_record_span_name = :default, this_span_name = :default)
+      span_for(this_span_name).overlap(test_record.span_for(test_record_span_name))
+    end
+    
+    def spans
+      acts_as_span_definitions.keys.map { |acts_as_span_definition_name| span_for(acts_as_span_definition_name) }
+    end
+    
+    def span
+      span_for(:default)
+    end
+    
+    def span_for(name = :default)
+      acts_as_span_klasses[name] ||= SpanKlass.new(name, self, acts_as_span_definitions[name])
+    end
+    
+    def acts_as_span_klasses
+      @_acts_as_span_klasses ||= {}
+    end
+  end
+  
+  module IncludedInstanceMethods
+    def spans
+      acts_as_span_definitions.keys.map { |acts_as_span_definition_name| span_for(acts_as_span_definition_name) }
+    end
+    
+    def span
+      span_for(:default)
+    end
+    
+    def span_for(name = :default)
+      acts_as_span_instances[name] ||= SpanInstance.new(name, self, acts_as_span_definitions[name])
+    end
+    
+    def acts_as_span_instances
+      @_acts_as_span_instances ||= {}
+    end
+    
+    def validate_spans
+      spans.each(&:validate)
+    end
+    
+    #This syntax assumes :default span
+    def overlap?(other_record)
+      overlap_for?(other_record, :default, :default)
+    end
+    
+    #record.span_for(:this_span_name).overlap?(other_record.span_for(:other_record_span_name))
+    def overlap_for?(other_record, this_span_name = :default, other_record_span_name = :default)
+      span_for(this_span_name).overlap?(other_record.span_for(other_record_span_name))
+    end
+  end
+  
+  module PositiveMethods
+    send(:define_method, "acts_as_span?") do
+      true
+    end
+  end
+  
+  module NegativeMethods
+    send(:define_method, "acts_as_span?") do
+      false
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, ActsAsSpan)

data/lib/acts_as_span/span_instance.rb

@@ -0,0 +1,53 @@
+require 'forwardable'
+
+require ACTS_AS_SPAN_PATH + 'span_instance/validations'
+require ACTS_AS_SPAN_PATH + 'span_instance/status'
+require ACTS_AS_SPAN_PATH + 'span_instance/overlap'
+
+module ActsAsSpan
+  class SpanInstance
+    extend Forwardable
+    
+    include ActsAsSpan::SpanInstance::Validations
+    include ActsAsSpan::SpanInstance::Status
+    include ActsAsSpan::SpanInstance::Overlap
+    
+    def_delegators :@acts_as_span_definition, :start_date_field,
+                                              :end_date_field,
+                                              :start_date_field_required,
+                                              :end_date_field_required,
+                                              :exclude_end,
+                                              :span_overlap_scope,
+                                              :span_overlap_count
+                                              
+    def_delegators :span_model, :new_record?
+    
+    attr_reader :name, :span_model, :acts_as_span_definition
+    
+    def initialize(name, span_model, acts_as_span_definition)
+      @name = name
+      @span_model = span_model
+      @acts_as_span_definition = acts_as_span_definition
+    end
+    
+    def span_klass
+      @span_klass ||= span_model.class
+    end
+    
+    def start_date
+      span_model[start_date_field]
+    end
+    
+    def end_date
+      span_model[end_date_field]
+    end
+    
+    def close!(close_date = Date.today)
+      if end_date.blank?
+        span_model.update_attributes!(end_date_field => close_date)
+      end
+    end
+    
+    alias_method :close_on!, :close!
+  end
+end

data/lib/acts_as_span/span_instance/overlap.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+
+module ActsAsSpan
+  class SpanInstance
+    module Overlap
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        #http://stackoverflow.com/questions/699448/ruby-how-do-you-check-whether-a-range-contains-a-subset-of-another-range
+        #start_date <= record_end_date && record_start_date <= end_date
+        def overlap?(other_span)
+          (start_date.nil? || other_span.end_date.nil? || start_date <= other_span.end_date) && (end_date.nil? || other_span.start_date.nil? || other_span.start_date <= end_date)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_span/span_instance/status.rb

@@ -0,0 +1,58 @@
+require 'active_support'
+
+module ActsAsSpan
+  class SpanInstance
+    module Status
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        def span_status(query_date = Date.today)
+          if future?(query_date)
+            :future
+          elsif expired?(query_date)
+            :expired
+          elsif current?(query_date)
+            :current
+          else
+            :unknown
+          end
+        end
+
+        alias_method :span_status_on, :span_status
+
+        def span_status_to_s(query_date = Date.today)
+          case span_status(query_date)
+          when :future
+            "Future"
+          when :expired
+            "Expired"
+          when :current
+            "Current"
+          when :unknown
+            "Unknown"
+          end
+        end
+
+        alias_method :span_status_to_s_on, :span_status_to_s
+        
+        def current?(query_date = Date.today)
+          !future?(query_date) && !expired?(query_date)
+        end
+        
+        alias_method :current_on?, :current?
+
+        def future?(query_date = Date.today)
+          start_date && start_date > query_date
+        end
+        
+        alias_method :future_on?, :future?
+
+        def expired?(query_date = Date.today)
+          end_date && end_date < query_date
+        end
+        
+        alias_method :expired_on?, :expired?
+      end
+    end
+  end
+end