time_span 0.0.1.alpha02

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in time_span.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/time_span.rb

@@ -0,0 +1,117 @@
+#require "time_span/version"
+require 'date'
+
+module TimeSpan
+    class TimeSpan
+
+    attr_accessor :starts, :ends     # RelativeTime objects
+
+    ##################################
+    ## time comparison               #
+    ##################################
+
+    def initialize(starting_at, ending_at)
+      self.starts = starting_at
+      self.ends   = ending_at
+      starting_at.kind_of?(RelativeTime) && ending_at.kind_of?(RelativeTime)
+    end
+
+
+    def starts_before?(b)
+      starts < b.starts
+    end
+
+    def starts_after?(b)
+      starts > b.starts
+    end
+
+    def starts_on_or_after?(b)
+      starts >= b.starts
+    end
+
+
+    def starts_with?(b)
+      starts == b.starts
+    end
+
+    def starts_before_or_with?(b)
+      starts <= b.starts
+    end
+
+    def ends_before?(b)
+      ends < b.ends
+    end
+
+    def ends_on_or_before?(b)
+      ends <= b.ends
+    end
+
+    def ends_on_or_after?(b)
+      ends >= b.ends
+    end
+
+    def ends_after?(b)
+      ends > b.ends
+    end
+
+    def ends_with?(b)
+      ends == b.ends
+    end
+
+    def ends_before_other_starts?(b)
+      ends < b.starts
+    end
+
+    def ends_as_other_starts?(b)
+      ends == b.starts
+    end
+
+    def starts_after_other_ends?(b)
+      starts > b.ends
+    end
+
+    def starts_as_other_ends?(b)
+      starts == b.ends
+    end
+
+    ##################################
+    ## span comparison               #
+    ##################################
+
+    ## >= and <=  intentionally not defined;
+
+
+    def == (b)
+      ends_with?(b) && starts_with?(b)
+    end
+
+    def < (b)
+      ends_before_other_starts?(b)
+    end
+
+    def > (b)
+      starts_after_other_ends?(b)
+    end
+
+    def contained_fully_inside?(b)
+      starts_after?(b) && ends_before?(b)
+    end
+
+    def contained_inside?(b)
+      starts_on_or_after?(b) && ends_on_or_before?(b)
+    end
+
+    def contains_fully?(b)
+      starts_before?(b) && ends_after?(b)
+    end
+
+    def contains?(b)
+      starts_before_or_with?(b) && ends_on_or_after?(b)
+    end
+
+  end
+
+  # first implementation is just as DateTime; later add fuzzy  time
+  class RelativeTime  < ::DateTime
+  end
+end

data/lib/time_span/version.rb

@@ -0,0 +1,3 @@
+module TimeSpan
+  VERSION = "0.0.1.alpha02"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'time_span'
+
+require 'bundler/setup'
+require 'rspec'
+require 'rspec/autorun'
+
+#RSpec.configure do |config|
+#
+#end
+

data/spec/time_span/time_span_spec.rb

@@ -0,0 +1,156 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+
+describe "TimeSpan" do
+
+  context "TimeSpan" do
+
+    context "instance methods" do
+
+      let (:alpha_start) do
+        TimeSpan::RelativeTime.parse("Jan 1, 2007")
+      end
+
+      let (:alpha_end) do
+       alpha_start + 2000
+      end
+
+
+      let (:alpha) do
+        TimeSpan::TimeSpan.new(alpha_start, alpha_end)
+      end
+
+      context "single time point comparators" do
+
+        context "same ends time, alpha starts before beta" do
+
+          let (:beta_start) do
+            TimeSpan::RelativeTime.parse("Jan 1, 2008")
+          end
+
+          let (:beta) do
+            TimeSpan::TimeSpan.new(beta_start, alpha_end)
+          end
+
+          context "alpha" do
+
+            it "starts before beta" do
+              alpha.should be_starts_before(beta)
+            end
+
+
+            it "ends with beta" do
+              alpha.should be_ends_with(beta)
+            end
+
+          end
+
+          context "alpha does not" do
+
+            it "start after beta" do
+              alpha.should_not be_starts_after(beta)
+            end
+
+            it "start with beta" do
+              alpha.should_not be_starts_with(beta)
+            end
+
+            it "end before beta" do
+              alpha.should_not be_ends_before(beta)
+            end
+
+            it "end after beta" do
+              alpha.should_not be_ends_after(beta)
+            end
+
+            it "end before beta starts" do
+              alpha.should_not be_ends_before_other_starts(beta)
+            end
+
+            it "end as beta starts" do
+              alpha.should_not be_ends_as_other_starts(beta)
+            end
+
+            it "start after beta ends" do
+              alpha.should_not be_starts_after_other_ends(beta)
+            end
+
+            it "start as beta ends" do
+              alpha.should_not be_starts_as_other_ends(beta)
+            end
+
+          end
+
+        end
+
+      end
+
+      context "time span comparators" do
+
+        let (:beta_earliest) do
+          alpha_start - 1000
+        end
+
+        let (:beta_before_alpha_starts) do
+          alpha_start - 500
+        end
+
+        let (:beta_after_alpha_starts) do
+          alpha_start + 500
+        end
+
+        let (:beta_before_alpha_ends) do
+          alpha_start + 1000
+        end
+
+        let (:beta_right_after_alpha_ends) do
+          alpha_end + 500
+        end
+
+        let (:beta_last) do
+          alpha_end + 1000
+        end
+
+        it "identical start and end times should return == as true" do
+          beta = TimeSpan::TimeSpan.new(alpha_start, alpha_end)
+          alpha.should == beta
+        end
+
+        it "alpha ends before beta starts, should return alpha < beta" do
+          beta = TimeSpan::TimeSpan.new(beta_right_after_alpha_ends, beta_last)
+          alpha.should < beta
+        end
+
+        it "alpha starts after beta ends, should return alpha > beta" do
+          beta = TimeSpan::TimeSpan.new(beta_earliest, beta_before_alpha_starts)
+          alpha.should > beta
+        end
+
+        it "alpha starting after and ending before beta should be contained inside beta" do
+          beta = TimeSpan::TimeSpan.new(beta_earliest, beta_last)
+          alpha.should be_contained_fully_inside(beta)
+        end
+
+        it "alpha starting with beta but ending before, is contained inside" do
+          beta = TimeSpan::TimeSpan.new(alpha_start, beta_last)
+          alpha.should be_contained_inside(beta)
+        end
+
+        it "alpha starting before and ending after full contains beta" do
+          beta = TimeSpan::TimeSpan.new(beta_after_alpha_starts, beta_before_alpha_ends)
+          alpha.should be_contains_fully(beta)
+        end
+
+        it "alpha starting before but ending with beta should contain beta" do
+          beta = TimeSpan::TimeSpan.new(beta_after_alpha_starts, alpha_end)
+          alpha.should be_contains(beta)
+        end
+
+      end
+
+    end
+
+  end
+
+
+
+end

data/time_span.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "time_span/version"
+
+Gem::Specification.new do |s|
+  s.name        = "time_span"
+  s.version     = TimeSpan::VERSION
+  s.authors     = ["Craig A. Cook"]
+  s.email       = ["craig.a.cook@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Time Span}
+  s.description = %q{Time spans, including many comparators}
+  s.license     = 'MIT'
+
+  s.rubyforge_project = "time_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"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: time_span
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha02
+  prerelease: 6
+platform: ruby
+authors:
+- Craig A. Cook
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70298360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70298360
+description: Time spans, including many comparators
+email:
+- craig.a.cook@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/time_span.rb
+- lib/time_span/version.rb
+- spec/spec_helper.rb
+- spec/time_span/time_span_spec.rb
+- time_span.gemspec
+homepage: ''
+licenses:
+- MIT
+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.1
+requirements: []
+rubyforge_project: time_span
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Time Span
+test_files: []