later_dude 0.2.1

data/CHANGELOG

@@ -0,0 +1,13 @@
+2009/10/30
+----------
+- Introduced new :yield_surrounding_days option to yield surrounding days of other months to passed block.
+
+2009/2/2
+---------
+- Introduced options to show and format next and previous month.
+- Replaced option :header_month_format with :current_month to align it with :next_month and :previous_month.
+- Removed some unused methods for month names.
+
+2009/1/14
+---------
+First release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Clemens Kofler
+
+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

@@ -0,0 +1,142 @@
+LaterDude
+=========
+
+LaterDude is a small calendar helper plugin for Rails with i18n support.
+
+It was heavily inspired by "Jeremy Voorhis'/Geoffrey Grosenbach's calendar_helper plugin":http://topfunky.net/svn/plugins/calendar_helper/. Here's what's different:
+
+  * LaterDude leverages the power of the "Rails i18n plugin":http://rails-i18n.org. This means that if you have Rails 2.2 or higher (or if you've installed the i18n gem and the plugin separately), you can just drop in locales and you'll get localized month and day names.
+  * Where the calendar_helper had one helper method that internally called multiple other private methods, LaterDude keeps the namespace clean by tucking away all of its functionality in a presenter (of sorts).
+  * Most CSS class names are given implictly, e.g. "day", "weekendDay" (both are given to the displayed month as well as to the previous and following month), "otherMonth" (all days that don't belong to the displayed month) and "today". The only CSS class that can be configured is the table's class (which defaults to "calendar"). Further customization can be taken care of by passing a block (see examples).
+
+Installation
+============
+
+You can use LaterDude either as a gem (preferred) or as a Rails plugin.
+
+To use the gem version, put the following gem requirement in your environment.rb:
+
+  config.gem "later_dude", :source => 'http://gemcutter.org'
+
+To install it as a plugin, fire up your terminal, go to your Rails app and type:
+
+  $ ruby script/plugin install git://github.com/clemens/later_dude.git
+
+Examples
+========
+
+There are two basic ways of outputting a calendar: via the presenter itself or by using the helper method:
+
+  <%= calendar_for(2009, 1) %> and
+  <%= LaterDude::Calendar.new(2009, 1).to_html %>
+  
+both yield the same results. This is similar to what Rails does with RedCloth/BlueCloth filters.
+
+In addition to year and month which are required parameters you can optionally supply an options hash:
+
+  <%= calendar_for(2009, 1, :calendar_class => "my_calendar", :first_day_of_week => 1)
+  
+Possible options are:
+
+  * :calendar_class: The CSS class for the surrounding table. Defaults to "calendar".
+  * :first_day_of_week: The first day of the week (0 = Sunday, 1 = Monday etc.). Defaults to the :'date.first_day_of_week' translation in the respective locale or 0 if no translation can be found.
+  * :hide_day_names: Hide the table header showing day names. Defaults to false.
+  * :hide_month_name: Hide the table header showing the month name. Defaults to false.
+  * :use_full_day_names: Use full instead of abbreviated day names. Defaults to false.
+  * :use_full_month_names: Use full instead of abbreviated month names. Defaults to true.
+  * :yield_surrounding_days: Defines whether or not days or the previous and next month are yielded to the passed block. Defaults to false.
+
+  * :next_month: Defines if and how the next month should be displayed. See section "Formatting the header section" for further information.
+  * :previous_month: Defines if and how the previous month should be displayed. See section "Formatting the header section" for further information.
+  * :next_and_previous_month: Defines if and how the next and previous month should be displayed. See section "Formatting the header section" for further information.
+  * :current_month: Defines how the current month should be displayed. See section "Formatting the header section" for further information.
+
+You can also pass in a block to mark days according to your own set of rules. The block gets passed each day of the current month (i.e. days of the previous and following month are *not* yielded):
+
+  <%= calendar_for(2009, 1) do |day|
+    if Calendar.has_events_on?(day)
+      [link_to(day.day, events_path(day.year, day.month, day.day)), { :class => "dayWithEvents" }]
+    else
+      day.day
+    end
+  end %>
+
+The block can either return an array containing two elements or a single value. If an array is returned, the first element will be the content of the table cell and the second will be used as HTML options for the table cell tag. If a single value is returned, it will be used as the content of the table cell.
+
+Hint: You can avoid cluttering up your views and move the block to a helper:
+
+  # app/helpers/calendar_helper.rb
+  def calendar_events_proc
+    lambda do |day|
+      if Calendar.has_events_on?(day)
+        [link_to(day.day, events_path(day.year, day.month, day.day)), { :class => "dayWithEvents" }]
+      else
+        day.day
+      end
+    end
+  end
+
+  # app/views/calendar/show.html
+  <%= calendar_for(2009, 1, &calendar_events_proc)
+
+Formatting the header section
+=============================
+
+You can customize the calendar's header section (i.e. the first table row) by using one or more of the following options:
+  * :next_month
+  * :previous_month
+  * :next_and_previous_month
+  * :current_month
+  
+All of these can either take a single value or an array of two values:
+
+  # simple string
+  :next_month => "&raquo;"
+  
+  # strftime string
+  :next_month => "%b"
+  
+  # proc - will evaluate the proc
+  :next_month => lambda { |date| link_to "&raquo;", calendar_path(date.year, month.year) }
+  
+  # simple string and proc - will evaluate the proc and use it for link_to, e.g. link_to("&raquo;", calendar_path(date.year, month.year))
+  :next_month => ["&raquo;", lambda { |date| calendar_path(date.year, month.year) }]
+
+  # strftime string and proc - will evaluate the proc and use it for link_to, e.g. link_to("Jan", calendar_path(date.year, month.year))
+  :next_month => ["%b", lambda { |date| calendar_path(date.year, month.year) }]
+  
+If you use a proc it gets passed a Date object carrying the respective month, i.e. the proc for :previous_month gets passed a Date object representing the previous month etc.
+
+You can do all kinds of mighty stuff with a proc. Imagine a situation where you want to show the abbreviated month name and then the number of events for the given month:
+  
+  # depending on your routes, this outputs something like <a href="/calendar/2009/1">Jan (3 events)</a>
+  :next_month => lambda { |date| link_to I18n.localize(date, :format => "%b (#{pluralize(Event.in_month(date))})", calendar_path(date.year, date.month) }
+
+The option :next_and_previous_month can be used as a shortcut if you want to use the same formatting for the next and previous month. Both, :next_month and :previous_month override the :next_and_previous_month if given.
+
+i18n
+====
+
+You can define the following keys in your locale files to customize output:
+
+  * date.formats.calendar_header: Defines the date format to be used for the table header.
+  * date.first_day_of_week: Defines the first day of a week (0 = Sunday, 1 = Monday etc.).
+
+Of course, you can also put other configuration options in the locale and then pass them in manually:
+
+  # somewhere in a locale
+  date:
+    calendar:
+      calendar_class: my_cool_calendar
+      
+  # in the view
+  <%= calendar_for(2009, 1, :calendar_class => I18n.translate(:'date.calendar.calendar_class', :default => "my_calendar"))
+
+Note that you should always pass in a default in case a translation can't be found since your options override the default options which might result in weird exceptions if the translation is missing.
+
+Bugs & Feedback
+===============
+
+You can send me feedback, bug reports and patches via "GitHub":http://github.com/clemens.
+
+Copyright (c) 2009 Clemens Kofler <clemens@railway.at>, released under the MIT license.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/distribution'
+require 'tasks/documentation'
+require 'tasks/testing'
+
+desc 'Default: run unit tests.'
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/init.rb

@@ -0,0 +1,2 @@
+require 'later_dude'
+ActionView::Base.send(:include, LaterDude::CalendarHelper)

data/lib/later_dude.rb

@@ -0,0 +1,212 @@
+require 'i18n'
+require 'action_view'
+
+module LaterDude
+  module CalendarHelper
+    def calendar_for(year, month, options={}, &block)
+      Calendar.new(year, month, options, &block).to_html
+    end
+  end
+
+  # TODO: Maybe make output prettier?
+  class Calendar
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::UrlHelper
+
+    def initialize(year, month, options={}, &block)
+      @year, @month = year, month
+      @options = options.symbolize_keys.reverse_merge(Calendar.default_calendar_options)
+
+      # next_month and previous_month take precedence over next_and_previous_month
+      @options[:next_month]     ||= @options[:next_and_previous_month]
+      @options[:previous_month] ||= @options[:next_and_previous_month]
+
+      @days = Date.civil(@year, @month, 1)..Date.civil(@year, @month, -1)
+      @block = block
+    end
+
+    def to_html
+      <<-EOF
+        <table class="#{@options[:calendar_class]}">
+          <thead>
+            #{show_month_names}
+            #{show_day_names}
+          </thead>
+          <tbody>
+            #{show_days}
+          </tbody>
+        </table>
+      EOF
+    end
+
+    private
+    def show_days
+      "<tr>#{show_previous_month}#{show_current_month}#{show_following_month}</tr>"
+    end
+
+    def show_previous_month
+      return if @days.first.wday == first_day_of_week # don't display anything if the first day is the first day of a week
+
+      returning "" do |output|
+        beginning_of_week(@days.first).upto(@days.first - 1) { |d| output << show_day(d) }
+      end
+    end
+
+    def show_current_month
+      returning "" do |output|
+        @days.first.upto(@days.last) { |d| output << show_day(d) }
+      end
+    end
+
+    def show_following_month
+      return if @days.last.wday == last_day_of_week # don't display anything if the last day is the last day of a week
+
+      returning "" do |output|
+        (@days.last + 1).upto(beginning_of_week(@days.last + 1.week) - 1) { |d| output << show_day(d) }
+      end
+    end
+
+    def show_day(day)
+      options = { :class => "day" }
+      options[:class] << " otherMonth" if day.month != @days.first.month
+      options[:class] << " weekend" if Calendar.weekend?(day)
+      options[:class] << " today" if day.today?
+
+      # block is only called for current month or if :yield_surrounding_days is set to true
+      if @block && (@options[:yield_surrounding_days] || day.month == @days.first.month)
+        content, options_from_block = Array(@block.call(day))
+
+        # passing options is optional
+        if options_from_block.is_a?(Hash)
+          options[:class] << " #{options_from_block.delete(:class)}" if options_from_block[:class]
+          options.merge!(options_from_block)
+        end
+      else
+        content = day.day
+      end
+
+      returning content_tag(:td, content, options) do |output|
+        if day < @days.last && day.wday == last_day_of_week # opening and closing tag for the first and last week are included in #show_days
+          output << "</tr><tr>" # close table row at the end of a week and start a new one
+        end
+      end
+    end
+
+    def beginning_of_week(day)
+      diff = day.wday - first_day_of_week
+      diff += 7 if first_day_of_week > day.wday # hackish ;-)
+      day - diff
+    end
+
+    def show_month_names
+      return if @options[:hide_month_name]
+
+      %(<tr class="month_names">
+        #{previous_month}#{current_month}#{next_month}
+      </tr>)
+    end
+
+    # @options[:previous_month] can either be a single value or an array containing two values. For a single value, the
+    # value can either be a strftime compatible string or a proc.
+    # For an array, the first value is considered to be a strftime compatible string and the second is considered to be
+    # a proc. If the second value is not a proc then it will be ignored.
+    def previous_month
+      return unless @options[:previous_month]
+
+      show_month(@days.first - 1.month, @options[:previous_month], :class => "previous")
+    end
+
+    # see previous_month
+    def next_month
+      return unless @options[:next_month]
+
+      show_month(@days.first + 1.month, @options[:next_month], :class => "next")
+    end
+
+    # see previous_month and next_month
+    def current_month
+      colspan = @options[:previous_month] || @options[:next_month] ? 3 : 7 # span across all 7 days if previous and next month aren't shown
+
+      show_month(@days.first, @options[:current_month], :colspan => colspan, :class => "current")
+    end
+
+    def show_month(month, format, options={})
+      options[:colspan] ||= 2
+
+      returning %(<th colspan="#{options[:colspan]}" class="#{options[:class]} #{Date::MONTHNAMES[month.month].downcase}">) do |output|
+        output << if format.kind_of?(Array) && format.size == 2
+          text = I18n.localize(month, :format => format.first.to_s)
+          format.last.respond_to?(:call) ? link_to(text, format.last.call(month)) : text
+        else
+          format.respond_to?(:call) ? format.call(month) : I18n.localize(month, :format => format.to_s)
+        end
+        output << '</th>'
+      end
+    end
+
+    def day_names
+      @day_names ||= @options[:use_full_day_names] ? full_day_names : abbreviated_day_names
+    end
+
+    def full_day_names
+      @full_day_names ||= I18n.translate(:'date.day_names')
+    end
+
+    def abbreviated_day_names
+      @abbreviated_day_names ||= I18n.translate(:'date.abbr_day_names')
+    end
+
+    def show_day_names
+      return if @options[:hide_day_names]
+
+      returning '<tr class="day_names">' do |output|
+        apply_first_day_of_week(day_names).each do |day|
+          output << %(<th scope="col" class="#{Date::DAYNAMES[day_names.index(day)].downcase}">#{include_day_abbreviation(day)}</th>)
+        end
+        output << "</tr>"
+      end
+    end
+
+    # => <abbr title="Sunday">Sun</abbr>
+    def include_day_abbreviation(day)
+      return day if @options[:use_full_day_names]
+
+      %(<abbr title="#{full_day_names[abbreviated_day_names.index(day)]}">#{day}</abbr>)
+    end
+
+    def apply_first_day_of_week(day_names)
+      names = day_names.dup
+      first_day_of_week.times { names.push(names.shift) }
+      names
+    end
+
+    def first_day_of_week
+      @options[:first_day_of_week]
+    end
+
+    def last_day_of_week
+      @options[:first_day_of_week] > 0 ? @options[:first_day_of_week] - 1 : 6
+    end
+
+    class << self
+      def weekend?(day)
+        [0,6].include?(day.wday) # 0 = Sunday, 6 = Saturday
+      end
+
+      def default_calendar_options
+        {
+          :calendar_class => "calendar",
+          :first_day_of_week => I18n.translate(:'date.first_day_of_week', :default => "0").to_i,
+          :hide_day_names => false,
+          :hide_month_name => false,
+          :use_full_day_names => false,
+          :current_month => I18n.translate(:'date.formats.calendar_header', :default => "%B"),
+          :next_month => false,
+          :previous_month => false,
+          :next_and_previous_month => false,
+          :yield_surrounding_days => false
+        }
+      end
+    end
+  end
+end

data/tasks/distribution.rb

@@ -0,0 +1,22 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = "later_dude"
+    s.summary     = "Small calendar helper plugin for Rails with i18n support"
+    s.email       = "clemens@railway.at"
+    s.homepage    = "http://github.com/clemens/later_dude"
+    s.description = "LaterDude is a small calendar helper plugin for Rails with i18n support."
+    s.authors     = ["Clemens Kofler"]
+    s.files       =  FileList["CHANGELOG",
+                              "init.rb",
+                              "lib/later_dude.rb",
+                              "MIT-LICENSE",
+                              "Rakefile",
+                              "README",
+                              "tasks/**/*.rb",
+                              "VERSION"]
+    s.test_files  = FileList["test/**/*.rb"]
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/tasks/documentation.rb

@@ -0,0 +1,8 @@
+desc 'Generate documentation for the later_dude plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'LaterDude'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/tasks/testing.rb

@@ -0,0 +1,7 @@
+desc 'Test the later_dude plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/test/calendar_helper_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class CalendarHelperTest < ActiveSupport::TestCase
+  include LaterDude::CalendarHelper
+
+  test "requires year and month" do
+    assert_raises(ArgumentError) { calendar_for }
+    assert_raises(ArgumentError) { calendar_for(2009) }
+    assert_nothing_raised { calendar_for(2009, 1) }
+  end
+
+  test "accepts optional options hash" do
+    options = { :calendar_class => "my_calendar", :first_day_of_week => 1 }
+    assert_nothing_raised { calendar_for(2009, 1, options) }
+  end
+
+  test "accepts optional block" do
+    options = { :calendar_class => "my_calendar", :first_day_of_week => 1 }
+    some_block = lambda { nil }
+
+    assert_nothing_raised { calendar_for(2009, 1, &some_block) }
+    assert_nothing_raised { calendar_for(2009, 1, options, &some_block) }
+  end
+end

data/test/calendar_test.rb

@@ -0,0 +1,255 @@
+require 'test_helper'
+
+# TODO: figure out why I have to reference Calendar via its module ...
+class CalendarTest < ActiveSupport::TestCase
+  # some constants for increased readability
+  FULL_DAY_NAMES   = I18n.translate(:'date.day_names')
+  ABBR_DAY_NAMES   = I18n.translate(:'date.abbr_day_names')
+  FULL_MONTH_NAMES = I18n.translate(:'date.month_names')
+  ABBR_MONTH_NAMES = I18n.translate(:'date.abbr_month_names')
+
+  test "has default options" do
+    # TODO improve this so that every call gets a fresh copy of the default options
+    default_calendar_options = LaterDude::Calendar.send(:default_calendar_options)
+
+    assert_kind_of Hash, default_calendar_options
+
+    assert_equal "calendar", default_calendar_options[:calendar_class]
+
+    [:hide_day_names, :hide_month_name, :use_full_day_names].each do |key|
+      assert !default_calendar_options[key]
+    end
+
+    # default date format for header is to show the full month name if no translation is set in locale
+    assert_equal "%B", default_calendar_options[:current_month]
+
+    # next and previous month aren't shown by default
+    assert !default_calendar_options[:next_month]
+    assert !default_calendar_options[:previous_month]
+    assert !default_calendar_options[:next_and_previous_month]
+
+    # some options use i18n ...
+    I18n.stubs(:translate).with(:'date.first_day_of_week', :default => "0").then.returns("1")
+    I18n.stubs(:translate).with(:'date.formats.calendar_header', :default => "%B").then.returns("%B %Y")
+
+    # default first day of week is Sunday (= 0) if no translation is set in locale
+    assert_equal 0, default_calendar_options[:first_day_of_week]
+    # with default first day of week set in locale
+    assert_equal 1, (LaterDude::Calendar.send(:default_calendar_options)[:first_day_of_week]) # have to do this so that we don't use the cached version
+
+    # with default date format set in locale
+    assert_equal "%B %Y", (LaterDude::Calendar.send(:default_calendar_options)[:current_month])
+  end
+
+  # options
+  test "uses full day names" do
+    assert_equal FULL_DAY_NAMES, LaterDude::Calendar.new(2009, 1, :use_full_day_names => true).send(:day_names)
+  end
+
+  test "uses abbreviated day names" do
+    assert_equal ABBR_DAY_NAMES, LaterDude::Calendar.new(2009, 1).send(:day_names)
+    assert_equal ABBR_DAY_NAMES, LaterDude::Calendar.new(2009, 1, :use_full_day_names => false).send(:day_names)
+  end
+
+  test "doesn't show day names" do
+    assert_nil LaterDude::Calendar.new(2009, 1, :hide_day_names => true).send(:show_day_names)
+  end
+
+  # TODO I think this isn't needed anymore due to the new :header_date_format option
+  test "doesn't show month names" do
+    assert_nil LaterDude::Calendar.new(2009, 1, :hide_month_name => true).send(:show_month_names)
+  end
+
+  # links/texts for next, previous and current month
+  test "uses next month for a string" do
+    assert_match %r(&raquo;), LaterDude::Calendar.new(2009, 1, :next_month => "&raquo;").send(:next_month)
+  end
+
+  test "uses next month for a strftime string" do
+    assert_match %r(Feb), LaterDude::Calendar.new(2009, 1, :next_month => "%b").send(:next_month)
+  end
+
+  test "uses next month for proc" do
+    assert_match %r(<a href="/events/2009/2">&raquo;</a>), LaterDude::Calendar.new(2009, 1, :next_month => lambda { |date| link_to "&raquo;", "/events/#{date.year}/#{date.month}" }).send(:next_month)
+  end
+
+  test "uses next month for array if first value is a string and second is a proc" do
+    assert_match %r(<a href="/events/2009/2">&raquo;</a>), LaterDude::Calendar.new(2009, 1, :next_month => ["&raquo;", lambda { |date| "/events/#{date.year}/#{date.month}" }]).send(:next_month)
+  end
+
+  test "uses next month for array if first value is a strftime string and second is a proc" do
+    assert_match %r(<a href="/events/2009/2">Feb</a>), LaterDude::Calendar.new(2009, 1, :next_month => ["%b", lambda { |date| "/events/#{date.year}/#{date.month}" }]).send(:next_month)
+  end
+
+  test "uses previous month for a string" do
+    assert_match %r(&laquo;), LaterDude::Calendar.new(2009, 1, :previous_month => "&laquo;").send(:previous_month)
+  end
+
+  test "uses previous month for a strftime string" do
+    assert_match %r(Dec), LaterDude::Calendar.new(2009, 1, :previous_month => "%b").send(:previous_month)
+  end
+
+  test "uses previous month for proc" do
+    assert_match %r(<a href="/events/2008/12">&laquo;</a>), LaterDude::Calendar.new(2009, 1, :previous_month => lambda { |date| link_to "&laquo;", "/events/#{date.year}/#{date.month}" }).send(:previous_month)
+  end
+
+  test "uses previous month for array if first value is a string and second is a proc" do
+    assert_match %r(<a href="/events/2008/12">&laquo;</a>), LaterDude::Calendar.new(2009, 1, :previous_month => ["&laquo;", lambda { |date| "/events/#{date.year}/#{date.month}" }]).send(:previous_month)
+  end
+
+  test "uses previous month for array if first value is a strftime string and second is a proc" do
+    assert_match %r(<a href="/events/2008/12">Dec</a>), LaterDude::Calendar.new(2009, 1, :previous_month => ["%b", lambda { |date| "/events/#{date.year}/#{date.month}" }]).send(:previous_month)
+  end
+
+  test "uses next and previous month for array if first value is a strftime string and second is a proc" do
+    calendar = LaterDude::Calendar.new(2009, 1, :next_and_previous_month => ["%b", lambda { |date| "/events/#{date.year}/#{date.month}" }])
+    assert_match %r(<a href="/events/2008/12">Dec</a>), calendar.send(:previous_month)
+    assert_match %r(<a href="/events/2009/2">Feb</a>), calendar.send(:next_month)
+  end
+
+  test "uses next/previous month options rather than combined option if both are given" do
+    calendar = LaterDude::Calendar.new(2009, 1, :next_month => "&raquo;", :previous_month => "&laquo;", :next_and_previous_month => ["%b", lambda { |date| "/events/#{date.year}/#{date.month}" }])
+    assert_match %r(&laquo;), calendar.send(:previous_month)
+    assert_match %r(&raquo;), calendar.send(:next_month)
+  end
+
+  test "uses current month for a string" do
+    assert_match %r(Current), LaterDude::Calendar.new(2009, 1, :current_month => "Current").send(:current_month)
+  end
+
+  test "uses current month for a strftime string" do
+    assert_match %r(Jan), LaterDude::Calendar.new(2009, 1, :current_month => "%b").send(:current_month)
+  end
+
+  test "uses current month for proc" do
+    assert_match %r(<a href="/events/2009/1">Current</a>), LaterDude::Calendar.new(2009, 1, :current_month => lambda { |date| link_to "Current", "/events/#{date.year}/#{date.month}" }).send(:current_month)
+  end
+
+  test "uses current month for array if first value is a string and second is a proc" do
+    assert_match %r(<a href="/events/2009/1">Current</a>), LaterDude::Calendar.new(2009, 1, :current_month => ["Current", lambda { |date| "/events/#{date.year}/#{date.month}" }]).send(:current_month)
+  end
+
+  test "uses current month for array if first value is a strftime string and second is a proc" do
+    assert_match %r(<a href="/events/2009/1">Jan</a>), LaterDude::Calendar.new(2009, 1, :current_month => ["%b", lambda { |date| "/events/#{date.year}/#{date.month}" }]).send(:current_month)
+  end
+
+  # helper methods
+  test "shows whether a given day is on a weekend or not" do
+    [0, 6].each { |day| assert  LaterDude::Calendar.weekend?(mock(:wday => day)) }
+    (1..5).each { |day| assert !LaterDude::Calendar.weekend?(mock(:wday => day)) }
+  end
+
+  test "includes day name abbreviation" do
+    assert_equal %q(<abbr title="Sunday">Sun</abbr>), LaterDude::Calendar.new(2009, 1, :use_full_day_names => false).send(:include_day_abbreviation, "Sun")
+  end
+
+  test "doesn't include day name abbreviation" do
+    assert_equal "Sunday", LaterDude::Calendar.new(2009, 1, :use_full_day_names => true).send(:include_day_abbreviation, "Sunday")
+  end
+
+  test "shows index of first and last day of week" do
+    assert_equal 0, LaterDude::Calendar.new(2009, 1).send(:first_day_of_week)
+    assert_equal 6, LaterDude::Calendar.new(2009, 1).send(:last_day_of_week)
+
+    assert_equal 1, LaterDude::Calendar.new(2009, 1, :first_day_of_week => 1).send(:first_day_of_week)
+    assert_equal 0, LaterDude::Calendar.new(2009, 1, :first_day_of_week => 1).send(:last_day_of_week)
+  end
+
+  test "applies first day of week accordingly" do
+    assert_equal %w(Mon Tue Wed Thu Fri Sat Sun), LaterDude::Calendar.new(2009, 1, :first_day_of_week => 1).send(:apply_first_day_of_week, ABBR_DAY_NAMES)
+  end
+
+  test "returns the first day of the week for a given date" do
+    day = Date.civil(2009, 1, 4) # first Sunday in 2009
+
+    assert_equal Date.civil(2009, 1, 4),   LaterDude::Calendar.new(2009, 1, :first_day_of_week => 0).send(:beginning_of_week, day)
+    assert_equal Date.civil(2008, 12, 29), LaterDude::Calendar.new(2009, 1, :first_day_of_week => 1).send(:beginning_of_week, day)
+    assert_equal Date.civil(2008, 12, 30), LaterDude::Calendar.new(2009, 1, :first_day_of_week => 2).send(:beginning_of_week, day)
+    assert_equal Date.civil(2008, 12, 31), LaterDude::Calendar.new(2009, 1, :first_day_of_week => 3).send(:beginning_of_week, day)
+    assert_equal Date.civil(2009, 1, 1),   LaterDude::Calendar.new(2009, 1, :first_day_of_week => 4).send(:beginning_of_week, day)
+    assert_equal Date.civil(2009, 1, 2),   LaterDude::Calendar.new(2009, 1, :first_day_of_week => 5).send(:beginning_of_week, day)
+    assert_equal Date.civil(2009, 1, 3),   LaterDude::Calendar.new(2009, 1, :first_day_of_week => 6).send(:beginning_of_week, day)
+  end
+
+  # TODO: may consider to mock some of the behavior so I don't have to use concrete months that fit for a test
+  test "shows previous month if first day of month isn't the first day of a week" do
+    assert_not_nil LaterDude::Calendar.new(2009, 4).send(:show_previous_month) # April 1st is a Wednesday
+  end
+
+  test "shows following month if last day of month isn't the last day of a week" do
+    assert_not_nil LaterDude::Calendar.new(2009, 4).send(:show_following_month) # April 30th is a Thursday
+  end
+
+  test "shouldn't show previous month if first day of month is the first day of a week" do
+    assert_nil LaterDude::Calendar.new(2009, 2).send(:show_previous_month) # February 1st is a Sunday
+  end
+
+  test "shouldn't show following month if last day of month is the last day of a week" do
+    assert_nil LaterDude::Calendar.new(2009, 2).send(:show_following_month) # February 28th is a Saturday
+  end
+
+  test "highlights current day (= today)" do
+    Date.stubs(:current).then.returns(Date.civil(2009, 1, 14))
+    assert_match %r(<td class="([^\"]*)today([^\"]*)">14</td>), LaterDude::Calendar.new(2009, 1).to_html
+  end
+
+  test "shows special days as designated by a block" do
+    CalendarTest.send(:include, ActionView::Helpers)
+
+    # all even days should be linked
+    special_days_proc = lambda do |day|
+      if day.day.even?
+        [link_to(day.day, "/calendar/#{day.year}/#{day.month}/#{day.day}"), { :class => "specialDay" } ]
+      else
+        day.day
+      end
+    end
+
+    calendar_html = LaterDude::Calendar.new(2009, 1, &special_days_proc).to_html
+
+    (Date.civil(2009, 1, 1)..Date.civil(2009, 1, -1)).each do |day|
+      if day.day.even?
+        assert_match %r(<td class="day([^\"]*)specialDay"><a href="/calendar/#{day.year}/#{day.month}/#{day.day}">#{day.day}</a></td>), calendar_html
+      else
+        assert_match %r(<td class="day([^\"]*)">#{day.day}</td>), calendar_html
+        assert_no_match %r(<td class="day([^\"]*)specialDay"><a href="/calendar/#{day.year}/#{day.month}/#{day.day}">#{day.day}</a></td>), calendar_html
+      end
+    end
+  end
+
+  test "yields days of surrounding months :yield_surrounding_days is set to true" do
+    CalendarTest.send(:include, ActionView::Helpers)
+
+    # make it bold
+    special_days_proc = lambda { |day| "<b>#{day.day}</b>" }
+
+    calendar_html = LaterDude::Calendar.new(2009, 4, { :yield_surrounding_days => true }, &special_days_proc).to_html
+
+    # start of first week: 29 March 2009
+    # end of last week: 2 May 2009
+    surrounding_days = [Date.civil(2009, 3, 29), Date.civil(2009, 3, 30), Date.civil(2009, 3, 31), Date.civil(2009, 5, 1), Date.civil(2009, 5, 2)]
+    surrounding_days.each do |day|
+      assert_match %r(<td class="day([^\"]*)otherMonth([^\"]*)"><b>#{day.day}</b></td>), calendar_html
+    end
+  end
+
+  test "yields days of surrounding months :yield_surrounding_days isn't set to true" do
+    CalendarTest.send(:include, ActionView::Helpers)
+
+    # make it bold
+    special_days_proc = lambda { |day| "<b>#{day.day}</b>" }
+
+    calendar_html  = LaterDude::Calendar.new(2009, 4, &special_days_proc).to_html
+    calendar_html2 = LaterDude::Calendar.new(2009, 4, { :yield_surrounding_days => false }, &special_days_proc).to_html
+
+    # start of first week: 29 March 2009
+    # end of last week: 2 May 2009
+    surrounding_days = [Date.civil(2009, 3, 29), Date.civil(2009, 3, 30), Date.civil(2009, 3, 31), Date.civil(2009, 5, 1), Date.civil(2009, 5, 2)]
+    surrounding_days.each do |day|
+      assert_no_match %r(<td class="day([^\"]*)otherMonth([^\"]*)"><b>#{day.day}</b></td>), calendar_html
+      assert_no_match %r(<td class="day([^\"]*)otherMonth([^\"]*)"><b>#{day.day}</b></td>), calendar_html2
+    end
+  end
+
+  # TODO: Should I do "real" output testing despite the good coverage of output-related methods? Testing HTML is tedious ...
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'
+
+require 'later_dude'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: later_dude
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Clemens Kofler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-31 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: LaterDude is a small calendar helper plugin for Rails with i18n support.
+email: clemens@railway.at
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- init.rb
+- lib/later_dude.rb
+- tasks/distribution.rb
+- tasks/documentation.rb
+- tasks/testing.rb
+has_rdoc: true
+homepage: http://github.com/clemens/later_dude
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Small calendar helper plugin for Rails with i18n support
+test_files: 
+- test/calendar_helper_test.rb
+- test/calendar_test.rb
+- test/test_helper.rb