time_frame 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 956de9d650db7ad301e9b4b903cd330b0630d866
-  data.tar.gz: 32c2a3d2249e19ee5ac6ad6335d15952c9278816
+  metadata.gz: efbf94fb0f87fe1ae9932c5adff2d7d2e0eecceb
+  data.tar.gz: 6333edbdc572720acfd58530eb9dc8d6cce0641c
 SHA512:
-  metadata.gz: 0b1fe690605128abd552bb893a6e4176343c453738f92efa9c935b8e7876d89ed358ca8ecf155f0af8ddd2d1e6b23ec712a5a778b0fd3c3700645eeab2cf8845
-  data.tar.gz: 92c452c7bcd63b6651d545a3d41ea15b11e48d575b02899a54ebe0726d0668fee25d54a0ecb6c2e79fbbd6f06b277fd26818ee4eff896f521f573c2d048308b0
+  metadata.gz: d7d02280bee7697e3403816914747f1881e0eabc328bccfbac33e1fe4789eaf43c058c51772589d2d9e888a956eb9fc8ebcf737f39582cd790dfb050424c2138
+  data.tar.gz: b361470e27cb987f9e653325a29db4e11489632a425e52dfaa140a29dac74a9b31a118811f4e0d9315d3e344cd2f9477336e3da3b30c820d2883c2df2b27d00a

data/lib/time_frame/collection.rb

@@ -0,0 +1,68 @@
+# Encoding: utf-8
+
+# This collection supports the concept of interval trees to improve the
+# access speed to intervals (or objects containing intervals) intersecting
+# given time_frames or covering time elements
+class Collection
+  attr_reader :tree_nodes, :root
+  def initialize(item_list = [], sorted = false, &block)
+    @block = block ? block : ->(item) { item }
+    @tree_nodes = item_list.map do |item|
+      TreeNode.new(item: item, &@block)
+    end
+
+    sort_list(@tree_nodes) unless sorted
+    build_tree(0, @tree_nodes.size - 1)
+    @root = @tree_nodes[(@tree_nodes.size - 1) / 2]
+  end
+
+  def all_covering(time)
+    result = []
+    add_covering(time, @root, result)
+    result.sort_by { |item | [@block.call(item).min, @block.call(item).max] }
+  end
+
+  def all_intersecting(time_frame)
+    result = []
+    add_intersecting(time_frame, @root, result)
+    result.sort_by { |item | [@block.call(item).min, @block.call(item).max] }
+  end
+
+  private
+
+  def sort_list(item_list)
+    item_list.sort_by! do |item|
+      [item.time_frame.min, item.time_frame.max]
+    end
+  end
+
+  def build_tree(lower, upper, ancestor = nil, side = nil)
+    mid = (lower + upper) / 2
+    node = @tree_nodes[mid]
+
+    node.update_ancestor_relation(ancestor, side) if ancestor && side
+
+    build_tree(lower, mid - 1, node, :left) unless lower == mid
+    build_tree(mid + 1, upper, node, :right) unless upper == mid
+
+    node.update_child_range(node.min_child, node.max_child) if lower == upper
+  end
+
+  def add_covering(time, node, result)
+    result << node.item if node.time_frame.cover?(time)
+    if node.continue_left_side_search_for_time?(time)
+      add_covering(time, node.left_child, result)
+    end
+    return unless node.continue_right_side_search_for_time?(time)
+    add_covering(time, node.right_child, result)
+  end
+
+  def add_intersecting(time_frame, node, result)
+    result << node.item unless (node.time_frame & time_frame).empty?
+    if node.continue_left_side_search_for_time_frame?(time_frame)
+      add_intersecting(time_frame, node.left_child, result)
+    end
+    return unless node.continue_right_side_search_for_time_frame?(time_frame)
+    add_intersecting(time_frame, node.right_child, result)
+  end
+end

data/lib/time_frame/tree_node.rb

@@ -0,0 +1,55 @@
+# Encoding: utf-8
+class Collection
+  # This is a helper class for the collection. It contains the node definition
+  # for the used tree structues.
+  class TreeNode
+    attr_accessor :max_child, :min_child, :left_child, :right_child
+    attr_reader :item, :time_frame, :ancestor
+    def initialize(args, &block)
+      @item = args.fetch(:item)
+      @time_frame = block.call(item)
+      # if ancestor is nil, then tree_item is root node
+      @ancestor = args.fetch(:ancestor, nil)
+      @left_child = args.fetch(:left_child, nil)
+      @right_child = args.fetch(:right_child, nil)
+
+      # if block is given use it to get item's time frame
+      @max_child = args.fetch(:max_child, @time_frame.max)
+      @min_child = args.fetch(:max_child, @time_frame.min)
+    end
+
+    def update_ancestor_relation(new_ancestor, side)
+      @ancestor = new_ancestor
+      new_ancestor.left_child = self if side == :left
+      new_ancestor.right_child = self if side == :right
+    end
+
+    def update_child_range(new_min_child, new_max_child)
+      @min_child = [@min_child, new_min_child].min
+      @max_child = [@max_child, new_max_child].max
+      ancestor.update_child_range(min_child, max_child) if ancestor
+    end
+
+    def continue_left_side_search_for_time?(time)
+      left_child &&
+      time >= left_child.min_child && time <= left_child.max_child
+    end
+
+    def continue_left_side_search_for_time_frame?(interval)
+      left_child &&
+      left_child.min_child <= interval.max &&
+      interval.min <= left_child.max_child
+    end
+
+    def continue_right_side_search_for_time?(time)
+      right_child &&
+      right_child.min_child <= time && time <= right_child.max_child
+    end
+
+    def continue_right_side_search_for_time_frame?(interval)
+      right_child &&
+      right_child.min_child <= interval.max &&
+      interval.min <= right_child.max_child
+    end
+  end
+end

data/lib/time_frame/version.rb

@@ -1,5 +1,5 @@
 # Encoding: utf-8
 # gem version
 class TimeFrame
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/lib/time_frame.rb

@@ -10,3 +10,6 @@ require 'time_frame/time_frame_overlaps'
 require 'time_frame/time_frame_uniter'
 
 require 'time_frame/time_frame'
+
+require 'time_frame/tree_node'
+require 'time_frame/collection'

data/spec/collection_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe Collection do
+
+  let(:time_frame) { TimeFrame.new(min: Time.utc(2014), duration: 20.days) }
+  let(:time) { Time.utc(2014) }
+
+  describe '#all_covering' do
+    context 'when a pure time_frame tree is given' do
+      it 'returns all covering time_frames' do
+        time_frames = 20.times.map { |i| time_frame.shift_by((5 * i).days) }
+        tree = Collection.new(time_frames)
+
+        result = tree.all_covering(time)
+        expected_result = time_frames.select { |t| t.cover?(time) }
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time - 1.day)
+        expect(result).to eq []
+
+        result = tree.all_covering(time + 5.days)
+        expected_result = time_frames.select { |t| t.cover?(time + 5.days) }
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time + 7.days)
+        expected_result = time_frames.select { |t| t.cover?(time + 7.days) }
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time + 17.days)
+        expected_result = time_frames.select { |t| t.cover?(time + 17.days) }
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time + 42.days)
+        expected_result = time_frames.select { |t| t.cover?(time + 42.days) }
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time + 300.days)
+        expect(result).to eq []
+      end
+    end
+
+    context 'when objects containing time_frames are given' do
+      it 'returns all covering time_frames' do
+        objects = 20.times.map do |i|
+          OpenStruct.new(time_frame: time_frame.shift_by((5 * i).days))
+        end
+        tree = Collection.new(objects) { |item| item.time_frame }
+
+        result = tree.all_covering(time - 1.day)
+        expect(result).to eq []
+
+        result = tree.all_covering(time + 5.days)
+        expected_result = objects.select do |t|
+          t.time_frame.cover?(time + 5.days)
+        end
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time + 7.days)
+        expected_result = objects.select do |t|
+          t.time_frame.cover?(time + 7.days)
+        end
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time + 17.days)
+        expected_result = objects.select do |t|
+          t.time_frame.cover?(time + 17.days)
+        end
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time + 42.days)
+        expected_result = objects.select do |t|
+          t.time_frame.cover?(time + 42.days)
+        end
+        expect(result).to eq expected_result
+
+        result = tree.all_covering(time + 300.days)
+        expect(result).to eq []
+      end
+    end
+  end
+
+  describe '#all_intersecting' do
+    context 'when a pure time_frame tree is given' do
+      it 'returns all intersecting time_frames' do
+        time_frames = 20.times.map { |i| time_frame.shift_by((5 * i).days) }
+        tree = Collection.new(time_frames)
+        interval = TimeFrame.new(min: time, duration: 1.hour)
+
+        result = tree.all_intersecting(interval.shift_by((-1).day))
+        expect(result).to eq []
+
+        result = tree.all_intersecting(interval)
+        expected_result = time_frames.select do |t|
+          !(t & (interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        this_interval = interval.shift_by(5.days)
+        result = tree.all_intersecting(this_interval)
+        expected_result = time_frames.select do |t|
+          !(t & (this_interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        this_interval = interval.shift_by(7.days)
+        result = tree.all_intersecting(this_interval)
+        expected_result = time_frames.select do |t|
+          !(t & (this_interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        this_interval = interval.shift_by(17.days)
+        result = tree.all_intersecting(this_interval)
+        expected_result = time_frames.select do |t|
+          !(t & (this_interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        this_interval = interval.shift_by(42.days)
+        result = tree.all_intersecting(this_interval)
+        expected_result = time_frames.select do |t|
+          !(t & (this_interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        result = tree.all_intersecting(interval.shift_by(300.days))
+        expect(result).to eq []
+      end
+    end
+
+    context 'when objects containing time_frames are given' do
+      it 'returns all intersecting time_frames' do
+        objects = 20.times.map do |i|
+          OpenStruct.new(time_frame: time_frame.shift_by((5 * i).days))
+        end
+        tree = Collection.new(objects) { |item| item.time_frame }
+        interval = TimeFrame.new(min: time, duration: 1.hour)
+
+        result = tree.all_intersecting(interval.shift_by((-1).day))
+        expect(result).to eq []
+
+        result = tree.all_intersecting(interval)
+        expected_result = objects.select do |object|
+          !(object.time_frame & (interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        this_interval = interval.shift_by(5.days)
+        result = tree.all_intersecting(this_interval)
+        expected_result = objects.select do |object|
+          !(object.time_frame & (this_interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        this_interval = interval.shift_by(7.days)
+        result = tree.all_intersecting(this_interval)
+        expected_result = objects.select do |object|
+          !(object.time_frame & (this_interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        this_interval = interval.shift_by(17.days)
+        result = tree.all_intersecting(this_interval)
+        expected_result = objects.select do |object|
+          !(object.time_frame & (this_interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        this_interval = interval.shift_by(42.days)
+        result = tree.all_intersecting(this_interval)
+        expected_result = objects.select do |object|
+          !(object.time_frame & (this_interval)).empty?
+        end
+        expect(result).to eq expected_result
+
+        result = tree.all_intersecting(interval.shift_by(300.days))
+        expect(result).to eq []
+
+      end
+    end
+  end
+end

data/spec/time_frame_spec.rb

@@ -77,6 +77,17 @@ describe TimeFrame do
           subject { super().max }
           it { should eq time }
         end
+
+        context 'when min is a date' do
+          context 'and duration is 0' do
+            it 'should be valid' do
+              expect do
+                TimeFrame.new(min: Date.new(2012), duration: 0.seconds)
+              end.not_to raise_error
+            end
+          end
+        end
+
       end
       context 'and time sframe covers a DST shift' do
         let(:time) do

data/time_frame.gemspec

@@ -28,7 +28,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'rake', '~> 10.3.2'
   spec.add_development_dependency 'rspec', '~> 3.0.0'
-  spec.add_development_dependency 'bundler', '~> 1.6.1'
   spec.add_development_dependency 'simplecov', '~> 0.8.2'
   spec.add_development_dependency 'rubocop', '~> 0.23.0'
   spec.add_dependency 'activesupport', '~> 4.1.1'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: time_frame
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Patrick Derichs
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-29 00:00:00.000000000 Z
+date: 2014-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -40,20 +40,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.6.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.6.1
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -113,13 +99,16 @@ files:
 - README.md
 - Rakefile
 - lib/time_frame.rb
+- lib/time_frame/collection.rb
 - lib/time_frame/empty.rb
 - lib/time_frame/time_frame.rb
 - lib/time_frame/time_frame_covered.rb
 - lib/time_frame/time_frame_overlaps.rb
 - lib/time_frame/time_frame_splitter.rb
 - lib/time_frame/time_frame_uniter.rb
+- lib/time_frame/tree_node.rb
 - lib/time_frame/version.rb
+- spec/collection_spec.rb
 - spec/spec_helper.rb
 - spec/time_frame_spec.rb
 - time_frame.gemspec
@@ -148,5 +137,6 @@ signing_key:
 specification_version: 4
 summary: Ruby gem that offers support for time frames
 test_files:
+- spec/collection_spec.rb
 - spec/spec_helper.rb
 - spec/time_frame_spec.rb