calendrier 0.9.0

data/lib/calendrier/helpers/event_helper.rb

@@ -0,0 +1,63 @@
+module Calendrier
+  module EventHelper
+
+    def count_sorted_events(events_by_date, cell_begin_time, cell_end_time)
+      counter = 0
+      sorted_events_do(events_by_date, cell_begin_time, cell_end_time) { |event| counter += 1 }
+      counter
+    end
+
+    def yield_sorted_events(events_by_date, cell_begin_time, cell_end_time, &block)
+      sorted_events_do(events_by_date, cell_begin_time, cell_end_time) { |event| yield event }
+    end
+
+    protected
+
+    def sorted_events_do(events_by_date, cell_begin_time, cell_end_time, &block)
+      begin 
+        unless events_by_date[cell_begin_time.year.to_s][cell_begin_time.month.to_s][cell_begin_time.day.to_s].nil?
+          events_by_date[cell_begin_time.year.to_s][cell_begin_time.month.to_s][cell_begin_time.day.to_s].each do |event|
+            yield event if display_event?(event, cell_begin_time, cell_end_time) # && block_given?
+          end
+        end
+      rescue NoMethodError
+      end
+    end
+
+    def display_event?(event, cell_begin_time, cell_end_time)
+      event_begin_time = nil
+      event_end_time = nil
+
+      if event.respond_to?(:year) && event.respond_to?(:month) && event.respond_to?(:day)
+        event_begin_time = Time.utc(event.year, event.month, event.day)
+        event_end_time = Time.utc(event.year, event.month, event.day, 23, 59, 59)
+      end
+
+      if event.respond_to?(:begin_time) && event.respond_to?(:end_time)
+        event_begin_time = event.begin_time
+        event_end_time = event.end_time
+      end     
+
+      if event_begin_time.to_i <= cell_begin_time.to_i
+        if event_end_time.to_i <= cell_end_time.to_i
+          if event_end_time.to_i > cell_begin_time.to_i         
+            ok = true
+          end
+        else
+          ok = true
+        end
+      else
+        if event_end_time.to_i <= cell_end_time.to_i
+          ok = true
+        else
+          if event_begin_time.to_i < cell_end_time.to_i
+            ok = true
+          end
+        end
+      end
+
+      return ok
+    end
+
+  end
+end

data/lib/calendrier/version.rb

@@ -0,0 +1,3 @@
+module Calendrier
+  VERSION = "0.9.0"
+end

data/test/lib/calendrier/calendrier_builder_test.rb

@@ -0,0 +1,175 @@
+require 'test_helper'
+
+describe Calendrier::CalendrierBuilder do
+  before do
+
+    ActionView::Base.send(:include, Calendrier::CalendrierHelper)
+    ActionView::Base.send(:include, Calendrier::EventHelper)
+    @view = ActionView::Base.new
+    @cal_options = { :year => 2012, :month => 5, :day => 25, :start_on_monday => true, :title => 'This is the calendar title' }
+
+    # preparing array for the month of may 2012
+    @days_of_may = []
+    @days_of_may << ''
+    31.times do |idx|
+      @days_of_may << (idx + 1).to_s
+    end
+    3.times { @days_of_may << '' }
+
+    # preparing array for the week of the 25th of may 2012
+    @days_of_may_weekly = []
+    24.times do |hour_idx|
+      @days_of_may_weekly << (hour_idx).to_s
+      7.times do |day_idx|
+        @days_of_may_weekly << ''
+      end
+    end
+
+  end
+
+  # builder
+
+  it "should require context and elements" do
+    proc { Calendrier::CalendrierBuilder::Builder.new }.must_raise ArgumentError
+  end
+
+  it "should raise NotImplementedError for Builder instance" do
+    builder = Calendrier::CalendrierBuilder::Builder.new(@view)
+    proc { builder.render }.must_raise NotImplementedError
+  end
+
+  # simple builder #
+
+  it "should respond to render for SimpleBuilder instance" do
+    builder = Calendrier::CalendrierBuilder::SimpleBuilder.new(@view)
+    #proc { builder.render }.must_raise NotImplementedError
+    builder.render(nil, nil)
+  end
+
+  it "should return valid code for monthly calendar" do
+    options = { :display => :month }
+    header, content = generate_header_and_content(options)
+    builder = Calendrier::CalendrierBuilder::SimpleBuilder.new(@view, options)
+    html_doc = Nokogiri::XML::Document.parse(builder.render(header, content).html_safe)
+    html_doc.errors.must_equal []
+  end
+
+  it "should return valid code for weekly calendar" do
+    options = { :display => :week }
+    header, content = generate_header_and_content(options)
+    builder = Calendrier::CalendrierBuilder::SimpleBuilder.new(@view, options)
+    html_doc = Nokogiri::XML::Document.parse(builder.render(header, content).html_safe)
+    html_doc.errors.must_equal []
+  end
+
+  it "should have the right calendar title" do
+    cal = generate_calendar(:month)
+    html_doc = Nokogiri::HTML(cal.html_safe)
+    calendar_title = html_doc.css('div.calendar > span').map { |link| link.children.to_s }.first
+    calendar_title.must_match /#{@cal_options[:title]}/
+  end
+
+
+  # monthly
+  it "should return the default monthly calendar" do
+    cal = generate_calendar(:month)
+    cal.must_match %r{calendar month}
+  end
+
+  it "should have the right amount of lines for monthly calendar" do
+    cal = generate_calendar(:month)
+    html_doc = Nokogiri::HTML(cal.html_safe)
+    calendar_lines = html_doc.css('div.calendar tr')
+    calendar_lines_count = html_doc.css('div.calendar tr').count
+    calendar_lines_count.must_equal 5
+  end
+
+  it "should have the right amount of columns for monthly calendar" do
+    cal = generate_calendar(:month)
+    html_doc = Nokogiri::HTML(cal.html_safe)
+    calendar_columns_count = html_doc.css('div.calendar td').count
+    calendar_columns_count.must_equal  5 * 7
+  end
+
+  it "should have the rights columns for monthly calendar" do
+    cal = generate_calendar(:month)
+    html_doc = Nokogiri::HTML(cal.html_safe)
+    calendar_columns_arr = html_doc.css('div.calendar td')
+    content_arr = calendar_columns_arr.map { |col| col.children.text.to_s }
+    content_arr.must_equal @days_of_may
+  end
+
+  # weekly
+  it "should return the weekly calendar" do
+    cal = generate_calendar(:week)
+    cal.must_match %r{calendar week}
+  end
+
+  it "should have the right amount of lines for weekly calendar" do
+    cal = generate_calendar(:week)
+    html_doc = Nokogiri::HTML(cal.html_safe)
+    calendar_lines_count = html_doc.css('div.calendar tr').count
+    calendar_lines_count.must_equal 24
+  end
+
+  it "should have the right amount of columns for monthly calendar" do
+    cal = generate_calendar(:week)
+    html_doc = Nokogiri::HTML(cal.html_safe)
+    calendar_columns_count = html_doc.css('div.calendar td').count
+    calendar_columns_count.must_equal  (1 + 7) * 24
+  end
+
+  it "should have the rights columns for monthly calendar" do
+    cal = generate_calendar(:week)
+    html_doc = Nokogiri::HTML(cal.html_safe)
+    calendar_columns_arr = html_doc.css('div.calendar td')
+    content_arr = calendar_columns_arr.map { |col| col.children.to_s }
+    content_arr.must_equal @days_of_may_weekly
+  end
+
+  def generate_calendar(display = :month)
+    options = @cal_options.merge :display => display
+    header, content = generate_header_and_content(options)
+    builder = Calendrier::CalendrierBuilder::SimpleBuilder.new(@view, options)
+    builder.render(header, content).html_safe
+  end
+
+  def generate_header_and_content(options = {})
+    display = options[:display] || :month
+    header = []
+    time_iterate(Time.utc(2012,5,21), Time.utc(2012,5,28)-1, 60*60*24) do |date|
+      header << date.to_date
+    end
+    content = []
+    content_intermediate = []
+    if display == :month
+      content_intermediate << content_hash(nil, nil)
+      time_iterate(Time.utc(2012,5,1), Time.utc(2012,5,31), 60*60*24) do |time|
+        content_intermediate << content_hash(time, nil)
+      end
+      3.times { content_intermediate << content_hash(nil, nil) }
+    else
+      24.times do |idx|
+        time_iterate(Time.utc(2012,5,21), Time.utc(2012,5,27), 60*60*24) do |time|
+          content_intermediate << content_hash(time + idx*60*60, nil)
+        end
+      end
+    end
+
+    (content_intermediate.count / 7).times do |idx|
+      content << content_intermediate.slice(idx * 7, 7)
+    end
+    [header, content]
+  end
+
+  def content_hash(time, content)
+    { time: time, content: content }
+  end
+
+  def time_iterate(start_time, end_time, step, &block)
+    begin
+      yield(start_time, start_time + step)
+    end while (start_time += step) <= end_time
+  end
+
+end

data/test/lib/calendrier/controllers/event_extension_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+describe Calendrier::EventExtension do
+  before do
+
+    ActionController::Base.send(:include, Calendrier::EventExtension)
+    @ctrl = ActionController::Base.new
+
+    de = FakeDailyEvent.new(2012,5,21)
+    de2 = FakeDailyEvent.new(2012,5,24)
+    le = FakeLongEvent.new(Time.utc(2012,5,23).to_i, Time.utc(2012,5,25,12).to_i)
+
+    @events_sorted_manually = {"2012"=>{
+                                    "5"=>{
+                                          "21"=>[ de ],
+                                          "23"=>[ le ],
+                                          "24"=>[ le, de2 ],
+                                          "25"=>[ le ],
+#                                         "26"=>[ le ] # this one should not be display
+                                         }
+                                       }
+                               }
+
+
+    @events_unordered = [ de, le, de2 ]
+
+    @events = @events_sorted_manually
+
+  end
+
+  it "should integrate with ActionController::Base" do
+    @ctrl.respond_to?(:sort_events).must_equal true
+  end
+
+  it "should return hash of events sorted by date" do
+   @ctrl.sort_events(@events_unordered).must_equal @events_sorted_manually
+  end
+
+end
+

data/test/lib/calendrier/helpers/calendrier_helper_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+describe Calendrier::CalendrierHelper do
+  before do
+
+    ActionView::Base.send(:include, Calendrier::CalendrierHelper)
+    ActionView::Base.send(:include, Calendrier::EventHelper)
+    @view = ActionView::Base.new
+    @cal_options = { :year => 2012, :month => 5, :day => 25, :start_on_monday => true }
+    de = FakeDailyEvent.new(2012,5,21)
+    de2 = FakeDailyEvent.new(2012,5,24)
+    le2 = FakeLongEvent.new(Time.utc(2012,5,23).to_i, Time.utc(2012,5,25).to_i)
+    @events_test = {"2012"=>{
+                                "5"=>{
+                                      "21"=>[ de ],
+                                      "23"=>[ le2 ],
+                                      "24"=>[ de2, le2 ],
+                                      "25"=>[ le2 ],
+                                      "26"=>[ le2 ] # this one should not be display
+                                     }
+                               }
+                      }
+
+    # preparing events counter array for the week of the 25th of may 2012
+    @counter_of_may_weekly = []
+    24.times { @counter_of_may_weekly = @counter_of_may_weekly + [1,0,1,2,0,0,0] }
+
+    # preparing events counter array for the week of the 25th of may 2012
+    @counter_of_may_monthly = []
+    20.times { @counter_of_may_monthly << 0 }
+    @counter_of_may_monthly << 1
+    @counter_of_may_monthly << 0
+    @counter_of_may_monthly << 1
+    @counter_of_may_monthly << 2
+    7.times { @counter_of_may_monthly << 0 }
+  end
+
+  it "should integrate with ActionView::Base" do
+    @view.respond_to?(:calendrier).must_equal true
+  end
+
+  it "should have the right amount of events for monthly calendar" do
+    counts = []
+    cal = @view.calendrier(@cal_options.merge :display => :month) do |cell_begin_time, cell_end_time|
+      counts << @view.count_sorted_events(@events_test, cell_begin_time, cell_end_time)
+    end
+    counts.must_equal @counter_of_may_monthly
+  end
+
+  it "should have the right amount of events for weekly calendar" do
+    counts = []
+    cal = @view.calendrier(@cal_options.merge :display => :week) do |cell_begin_time, cell_end_time|
+      counts << @view.count_sorted_events(@events_test, cell_begin_time, cell_end_time)
+    end
+    counts.must_equal @counter_of_may_weekly
+  end
+
+
+end
+

data/test/lib/calendrier/helpers/event_helper_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+describe Calendrier::EventHelper do
+  before do
+
+    #ActionView::Base.send(:include, Calendrier::CalendrierHelper)
+    ActionView::Base.send(:include, Calendrier::EventHelper)
+    @view = ActionView::Base.new
+    @cal_options = { :year => 2012, :month => 5, :day => 25, :start_on_monday => true }
+
+    de = FakeDailyEvent.new(2012,5,21)
+    de2 = FakeDailyEvent.new(2012,5,24)
+    le = FakeLongEvent.new(Time.utc(2012,5,23).to_i, Time.utc(2012,5,25,12).to_i)
+
+    @events_sorted_manually = {"2012"=>{
+                                    "5"=>{
+                                          "21"=>[ de ],
+                                          "23"=>[ le ],
+                                          "24"=>[ le, de2 ],
+                                          "25"=>[ le ],
+                                         }
+                                       }
+                               }
+
+#                                          "26"=>[ le ] # this one should not be displayed
+
+    @events = @events_sorted_manually
+
+  end
+
+  it "should integrate with ActionView::Base" do
+    @view.respond_to?(:count_sorted_events).must_equal true
+    @view.respond_to?(:yield_sorted_events).must_equal true
+  end
+
+  it "should count only one event" do
+    cell_begin_time = Time.utc(2012, 5, 23, 12)
+    cell_end_time = Time.utc(2012, 5, 23, 13)
+    @view.count_sorted_events(@events, cell_begin_time, cell_end_time).must_equal 1
+  end
+
+  it "should count the two events" do
+    cell_begin_time = Time.utc(2012, 5, 24, 12)
+    cell_end_time = Time.utc(2012, 5, 24, 13)
+    @view.count_sorted_events(@events, cell_begin_time, cell_end_time).must_equal 2
+  end
+
+  it "should count the right amount of events in the month" do
+    calendar_begin_time = Time.utc(2012, 5, 1)
+    calendar_end_time = Time.utc(2012, 5, 31)
+    events_count_of_may = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0]
+
+    step = 60 * 60 * 24 # 1.day
+
+    events_counts = []
+
+    time_iterate(calendar_begin_time, calendar_end_time, step) do |cell_begin_time, cell_end_time|
+      events_counts << @view.count_sorted_events(@events, cell_begin_time, cell_end_time)
+    end
+
+    events_counts.must_equal events_count_of_may
+  end
+
+  it "should count the right amount of events in the week" do
+    calendar_begin_time = Time.utc(2012, 5, 21, 0)
+    calendar_end_time = Time.utc(2012, 5, 27, 23, 59, 59)
+    events_count_of_one_week_in_may = []
+    24.times { events_count_of_one_week_in_may << 1 }
+    24.times { events_count_of_one_week_in_may << 0 }
+    24.times { events_count_of_one_week_in_may << 1 }
+    24.times { events_count_of_one_week_in_may << 2 }
+    12.times { events_count_of_one_week_in_may << 1 }
+    (12+24+24).times { events_count_of_one_week_in_may << 0 }
+
+    step = 60 * 60 # 1.hour
+
+    events_counts = []
+
+    time_iterate(calendar_begin_time, calendar_end_time, step) do |cell_begin_time, cell_end_time|
+      events_counts << @view.count_sorted_events(@events, cell_begin_time, cell_end_time)
+    end
+
+    events_counts.must_equal events_count_of_one_week_in_may
+  end
+
+
+  def time_iterate(start_time, end_time, step, &block)
+    begin
+      yield(start_time, start_time + step)
+    end while (start_time += step) <= end_time
+  end
+
+end
+

data/test/lib/calendrier/version_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+describe Calendrier do
+
+  it "must be defined" do
+    Calendrier::VERSION.wont_be_nil
+  end
+
+end