simple_calendar 0.1.11 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b46fa1a91f987c5e308a4bf435365dd6ae4bee1b
-  data.tar.gz: 71cf6c5d9b33d48cad89d779fff7df6603506c45
+  metadata.gz: fc702d5bfc9216617da9921539291ed03e61fd97
+  data.tar.gz: 4eec246dd685d28eea8f822483380c9121e53912
 SHA512:
-  metadata.gz: 6d9d0a0aea3af9d70a2d29a421bca603c18cbb24d4ab4516e3aa9ad9213303a2b406bba420607e9a96a117682e3f101964093ac41d013900c9bed18c193c0b40
-  data.tar.gz: 8ce4d3ebcf32cf966c69e92391e5518152d83ce91a6ae602063fad7ede933b289b76a5374856744e286d0e619c88b1c83944b20f1af1fa65af29d380516f25d2
+  metadata.gz: 45d62759c32d0a1ec5dadf6ebe3d819f8604bef0c4d99f5e45832d4e0d5815d001f788155d39d5067ee66979298ec23ac035b37940b571c7c00ca0c909bd8aa0
+  data.tar.gz: b0ece55d4cac8003ca070a9bd8803e02c7ce6f9c6ca6f7357f65eaa4db12540e2a5f0de00544589b4ac1446ce5c91a489c131f945da852086376a24bdd26b7fe

data/.gitignore

@@ -2,4 +2,3 @@
 .bundle
 Gemfile.lock
 pkg/*
-vendor/bundle

data/Gemfile

@@ -1,9 +1,3 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in simple_calendar.gemspec
 gemspec
-
-group :test do
-  gem 'rspec'
-  gem 'pry'
-end

data/README.md

@@ -1,158 +1,172 @@
 Simple Calendar
 ===============
 
-This is a small Rails 3.2 gem for creating a quick and clean table calendar.
-Theming is up to you, but it works nicely with Twitter Bootstrap. It's
-compatible with pure Ruby classes, ActiveRecord, Mongoid, and any other
-ORM.
+Simple Calendar is design to do one thing really really well: render a
+calendar. It lets you render a calendar of any size. Maybe you want a
+day view, a 4 day agenda, a week view, a month view, or a 6 week
+calendar. You can do all of that with the new gem, just give it a range
+of dates to render.
 
-Thanks to all of the awesome contributors!
+It doesn't depend on any ORM so you're free to use it with ActiveRecord,
+Mongoid, any other ORM, or pure Ruby objects.
+
+Thanks to all contributors for your wonderful help!
 
 Installation
 ------------
 
 Just add this into your Gemfile followed by a bundle install:
 
-    gem "simple_calendar", "~> 0.1.10"
+    gem "simple_calendar", "~> 1.0.0"
 
 Usage
 -----
 
-#### Model
-
-SimpleCalendar will look for a method on your model called `start_time`.
-This is used to determine the day and time of the event. This should be
-a `DateTime` object or at least respond similarly.
+Generating calendars is extremely simple with simple_calendar in version 1.0.
 
-The simplest way to use SimpleCalendar is to have an attribute on your
-model called `start_time` and you won't need to make any changes to your
-model at all. For example, I used `rails g model Event name:string
-start_time:datetime` to generate this class:
+The first parameter is a symbol that looks up the current date in
+`params`. If no date is found, it will use the current date.
 
-```ruby
-class Event < ActiveRecord::Base
-  attr_accessible :name, :start_time
-end
-```
+In these examples, we're using `:start_date` which is the default.
 
-If you don't have an attribute called `start_time` on your model, you
-can simply delegate like so:
+### Month Calendar
 
-```ruby
-class Event < ActiveRecord::Base
-  attr_accessible :name, :event_start_time
+You can generate a calendar for the month with the `month_calendar`
+method.
+This will use `params[:start_date]` to render the calendar.
 
-  def start_time
-    event_start_time
-  end
-end
+```erb
+<%= month_calendar :start_date do |day| %>
+  <%= day %>
+<% end %>
 ```
 
-As long as `start_time` returns a `DateTime` object, you're good to go.
-This means SimpleCalendar is now compatible with any class, whether it's
-ORM backed like ActiveRecord, Mongoid, or it's just a pure Ruby class.
-(Yay!)
+### Week Calendar
 
-##### Querying
+You can generate a week calendar with the `week_calendar` method.
+This will use `params[:start_date]` to render the calendar.
 
-SimpleCalendar uses `params[:month]` and `params[:year]` to determine
-which month of the calendar to render. You can use these to make your
-database queries more efficient.
+```erb
+<%= week_calendar :start_date, number_of_weeks: 2 do |day| %>
+  <%= day %>
+<% end %>
+```
 
-#### Views
+Setting `number_of_weeks` is optional and defaults to 1.
 
-SimpleCalendar just accepts an array of events and a block. The block
-will be executed for each event so you can provide your own logic for
-displaying the events.
+### Custom Length Calendar
 
-Here's an example that uses SimpleCalendar to simply render a link to
-each event on its own line inside the table. You would simply query for
-the `@events` as discussed above in the querying section.
+You can generate calendars of any length by passing in the number of days you want to render.
+This will use `params[:start_date]` to render the calendar.
 
 ```erb
-<%= calendar @events do |event| %>
-  <div><%= link_to event.title, event %></div>
+<%= calendar :start_date, number_of_days: 4 do |day| %>
+  <%= day %>
 <% end %>
 ```
 
-When the calendar is rendering, it yields to the block to allow you to
-render whatever you like for the item. In this example, I use the title
-attribute on the event with a link to the event.
+Setting `number_of_days` is optional and defaults to 4.
 
-You may even pass options to calendar renderer to customize it's behavior
+## Customizing The Calendar
 
-```erb
-<%= calendar @events, {:prev_text=>"prev", :next_text=>"next"} do |event| %>
-  <div><%= link_to event.title, event %></div>
-<% end %>
+You can change a couple of global options that will affect how the
+calendars are generated:
+
+```ruby
+Time.zone = "Central Time (US & Canada)"
 ```
 
-This time calendar will use prev and next as labels for previous and next month
-links (which are normally set to &amp;laquo; (&laquo;) and &amp;raquo; (&raquo;)
+Setting `Time.zone` will make sure the calendar start days are correctly computed
+in the right timezone. You can set this globally in your `application.rb` file or
+if you have a User model with a time_zone attribute, you can set it on every request by using
+a before_filter like the following example.
 
-Possible options:
+This code example uses [Devise](https://github.com/plataformatec/devise)'s
+`current_user` and `user_signed_in?` methods to retrieve the user's timezone and set it for the duration of the request.
+Make sure to change the `:user_signed_in?` and `current_user` methods if you are
+using some other method of authentication.
 
-    :year            # current year, default: from params or current year
-    :month           # current month, default: from params or current month
-    :prev_text       # previous month link text, default: &laquo;
-    :next_text       # next month link text, default: &raquo;
-    :start_day       # starting day of week, default: :sunday
-    :empty_date      # block called when a date is empty
-    :class           # HTML class attribute for the calendar
-    :params          # Any extra params you'd like in the URL (automatically includes month and year)
-    :dont_display_year #Set to true to remove the year in the table header
+```ruby
+class ApplicationController < ActionController::Base
+  before_filter :set_time_zone, if: :user_signed_in?
 
-If you wish to have Monday as the first day of the week, you'll need to
-change a couple things. First, when rendering the calendar, use the
-`:start_day => :monday` option like so:
+  private
 
-```erb
-<%= calendar @events, :start_day => :monday do |event| %>
-  <%= link_to event.title, event %>
-<% end %>
+    def set_time_zone
+      Time.zone = current_user.time_zone
+    end
+end
 ```
 
-And the second step is to make sure you've set your `I18n.locale` to the
-correct one. There is a lot of information here regarding use of locales in Rails:
-https://github.com/svenfuchs/rails-i18n
-
-The `empty_date` option accepts a block that will be called when a day
-in the calendar is empty. It will be called with the date object that
-represents the day that has no events.
+You can also change the beginning day of the week. If you want to set
+this globally, you can put this line in
+`config/initializers/simple_calendar.rb`:
 
-```erb
-  <%= calendar @events, empty_date: lambda{ |date| "hello from #{date}" } do |event| %>
-    <%= event.name %>
-  <% end %>
+```ruby
+Date.beginning_of_week = :sunday
 ```
-The `not_empty_date` option accepts a block that will be called when a day
-in the calendar has at least one event. It will be called with the date object that
-represents the day that has some events.
 
-```erb
-  <%= calendar @events, not_empty_date: lambda{ |date| "hello from #{date}" } do |event| %>
-    <%= event.name %>
-  <% end %>
+Setting classes on the table and elements are pretty:
+
+```ruby
+
+<%= calendar :start_date,
+  table: {class: "table table-bordered"},
+  tr: {class: "row"},
+  td: {class: "day"}, do |day| %>
+<% end %>
 ```
 
+This will set the class of `table table-bordered` on the `table` HTML
+element.
+
+Each of the `table`, `tr`, and `td`, options are passed directly to the
+the `content_tag` method so each of them **must** be a hash.
+
+### Custom Header Links
 
-CSS
----
+Each of the calendar methods will generate a header with links to the
+previous and next views. The `month_calendar` also includes a header
+that tells you the current month and year that you are viewing.
 
-You will probably want to customize the height of the calendar so that
-all the rows are the same heights and widths. You can do this by adding
-the following line to your css:
+To change these, you can pass in the `prev_link`, `header`, and
+`next_link` options into the calendar methods.
 
-```css
-.calendar td { height: 100px; width: 14.28%; }
+The default `month_calendar` look like this:
+
+```erb
+<%= month_calendar :start_date,
+  prev_link: ->(range) { link_to raw("&laquo;"), param_name => range.first - 1.day },
+  header: ->{ content_tag :span, "#{I18n.t("date.month_names")[start_date.month]} #{start_date.year}", class: "calendar-header" },
+  next_link: ->(range) { link_to raw("&raquo;"), param_name => range.last + 1.day } do |day| %>
+
+<% end %>
 ```
 
-By default simple_calendar will set the calendar to use .table
-.table-bordered .table-striped and .calendar classes.
+The `prev_link` option is a standard `link_to` that is a left arrow and
+with the current url having `?start_date=2014-04-30` appended to it as
+a date in the previous view of the calendar.
+
+The `next_link` option is a standard `link_to` that is a right arrow and
+with the current url having `?start_date=2014-06-01` appended to it as
+a date in the next view of the calendar.
 
-You can also override the class by passing in the `class` option.
+The `header` option is just a simple span tag with the month and year
+inside of it.
+
+If you wish to disable any of these partsof the header, just pass in
+`false` and that will hide it:
 
 ```erb
-  <%= calendar @events, class: "simple-calendar" do |event| %>
-  <% end %>
+<%= month_calendar :start_date, header: false do |day| %>
+<% end %>
 ```
+
+
+## Author
+
+Chris Oliver <chris@gorails.com>
+
+[https://gorails.com](https://gorails.com)
+
+[@excid3](https://twitter.com/excid3)

data/lib/simple_calendar/version.rb

@@ -1,3 +1,3 @@
 module SimpleCalendar
-  VERSION = "0.1.11"
+  VERSION = "1.0.0"
 end

data/lib/simple_calendar/view_helpers.rb

@@ -1,119 +1,120 @@
 module SimpleCalendar
   module ViewHelpers
+    def month_calendar(param_name=:start_date, options={}, &block)
+      start_date = (params[param_name] || Time.zone.now).to_date
+
+      options.reverse_merge!(
+        prev_link: ->(range) { link_to raw("«"), param_name => range.first - 1.day },
+        header: ->{ content_tag :span, "#{I18n.t("date.month_names")[start_date.month]} #{start_date.year}", class: "calendar-header" },
+        next_link: ->(range) { link_to raw("»"), param_name => range.last + 1.day },
+      )
+      render_calendar month_range(start_date), options, &block
+    end
+
+    def week_calendar(param_name=:start_date, options={}, &block)
+      start_date = (params[param_name] || Time.zone.now).to_date
+      number_of_weeks = options.fetch(:number_of_weeks, 1)
 
-    def calendar(events, options={}, &block)
-      raise 'SimpleCalendar requires a block to be passed in' unless block_given?
+      options.reverse_merge!(
+        prev_link: ->(range) { link_to raw("«"), param_name => range.first - 1.day },
+        header: false,
+        next_link: ->(range) { link_to raw("»"), param_name => range.last + 1.day },
+      )
+      render_calendar week_range(start_date, number_of_weeks), options, &block
+    end
 
-      opts = default_options
-      options.reverse_merge! opts
-      events       ||= []
-      selected_month = Date.new(options[:year], options[:month])
-      current_date   = Time.zone.now.to_date
-      range          = build_range selected_month, options
-      month_array    = range.each_slice(7).to_a
+    def calendar(param_name=:start_date, options={}, &block)
+      start_date = (params[param_name] || Time.zone.now).to_date
+      number_of_days_to_advance = options.fetch(:number_of_days, 4) - 1
 
-      draw_calendar(selected_month, month_array, current_date, events, options, block)
+      options.reverse_merge!(
+        prev_link: ->(range) { link_to raw("«"), param_name => range.first - 1.day },
+        header: false,
+        next_link: ->(range) { link_to raw("»"), param_name => range.last + 1.day },
+      )
+      render_calendar calendar_range(start_date, number_of_days_to_advance), options, &block
     end
 
-    private
-    def default_options
-      {
-        :year           => (params[:year] || Time.zone.now.year).to_i,
-        :month          => (params[:month] || Time.zone.now.month).to_i,
-        :prev_text      => raw("«"),
-        :next_text      => raw("»"),
-        :start_day      => :sunday,
-        :class          => "table table-bordered table-striped calendar",
-        :params         => {},
-        :time_selector  => "start_time",
-        :dont_display_year   => false
-      }
+    def month_range(start_date)
+      start_date.beginning_of_month.beginning_of_week.to_date..start_date.end_of_month.end_of_week.to_date
     end
-    # Returns array of dates between start date and end date for selected month
-    def build_range(selected_month, options)
-      start_date = selected_month.beginning_of_month.beginning_of_week(options[:start_day])
-      end_date   = selected_month.end_of_month.end_of_week(options[:start_day])
 
-      (start_date..end_date).to_a
+    def week_range(start_date, number_of_weeks)
+      number_of_days_to_advance = (number_of_weeks * 7) - 1
+      starting_day              = start_date.beginning_of_week.to_date
+      ending_day                = starting_day + number_of_days_to_advance.days
+      starting_day..ending_day
     end
 
-    # Renders the calendar table
-    def draw_calendar(selected_month, month, current_date, events, options, block)
-      tags = []
-      today = Time.zone.now.to_date
-      content_tag(:table, :class => options[:class]) do
-        tags << month_header(selected_month, options)
-        day_names = I18n.t("date.abbr_day_names")
-        day_names = day_names.rotate((Date::DAYS_INTO_WEEK[options[:start_day]] + 1) % 7)
-        tags << content_tag(:thead, content_tag(:tr, day_names.collect { |name| content_tag :th, name, :class => (selected_month.month == today.month && today.strftime("%a") == name ? "current-day" : nil)}.join.html_safe))
-        tags << content_tag(:tbody, :'data-month'=>selected_month.month, :'data-year'=>selected_month.year) do
-
-          month.collect do |week|
-            content_tag(:tr, :class => (week.include?(today) ? "current-week week" : "week")) do
-
-              week.collect do |date|
-                td_class = ["day"]
-                td_class << "today" if today == date
-                td_class << "not-current-month" if selected_month.month != date.month
-                td_class << "past" if today > date
-                td_class << "future" if today < date
-                td_class << "wday-#{date.wday.to_s}" # <- to enable different styles for weekend, etc
-
-                cur_events = day_events(date, events, options[:time_selector])
-
-                td_class << (cur_events.any? ? "events" : "no-events")
-
-                content_tag(:td, :class => td_class.join(" "), :'data-date-iso'=>date.to_s, 'data-date'=>date.to_s.gsub('-', '/')) do
-                  content_tag(:div) do
-                    divs = []
-                    concat content_tag(:div, date.day.to_s, :class=>"day_number")
-
-                    if cur_events.empty? && options[:empty_date]
-                      concat options[:empty_date].call(date)
-                    else
-                      if options[:not_empty_date]
-                        concat options[:not_empty_date].call(date)
-                      end
-                      divs << cur_events.collect{ |event| block.call(event) }
-                    end
-
-                    divs.join.html_safe
-                  end #content_tag :div
-                end #content_tag :td
-
-              end.join.html_safe
-            end #content_tag :tr
-
-          end.join.html_safe
-        end #content_tag :tbody
-
-        tags.join.html_safe
-      end #content_tag :table
+    def calendar_range(start_date, number_of_days_to_advance)
+      start_date..(start_date + number_of_days_to_advance.days)
     end
 
-    # Returns an array of events for a given day
-    def day_events(date, events, time_selector)
-      events.select { |e| e.send(time_selector).to_date == date }.sort_by { |e| e.send(time_selector) }
+    def render_calendar(range, options, &block)
+      raise 'SimpleCalendar requires a block' unless block_given?
+
+      @block   = block
+      @options = options.reverse_merge default_options
+
+      capture do
+        concat render_header(range)
+        concat render_table(range)
+      end
     end
 
-    # Generates the header that includes the month and next and previous months
-    def month_header(selected_month, options)
-      content_tag :h2 do
-        previous_month = selected_month.advance :months => -1
-        next_month = selected_month.advance :months => 1
-        tags = []
+    def render_header(range)
+      capture do
+        content_tag :div do
+          concat get_options(@options[:prev_link], range)
+          concat get_options(@options[:header])
+          concat get_options(@options[:next_link], range)
+        end
+      end
+    end
 
-        tags << month_link(options[:prev_text], previous_month, options[:params], {:class => "previous-month"})
-        tags << "#{I18n.t("date.month_names")[selected_month.month]} #{selected_month.year unless options[:dont_display_year]}".strip
-        tags << month_link(options[:next_text], next_month, options[:params], {:class => "next-month"})
+    def render_table(range)
+      content_tag(:table, get_options(@options[:table])) do
+        content_tag(:tbody) do
+          render_weeks(range)
+        end
+      end
+    end
+
+
+    def render_weeks(range)
+      weeks = []
+      range.each_slice(7) do |week|
+        weeks << content_tag(:tr, get_options(@options[:tr], week)) do
+          render_week(week)
+        end
+      end
+      safe_join weeks
+    end
 
-        tags.join.html_safe
+    def render_week(week)
+      results = week.map do |day|
+        content_tag :td, get_options(@options[:td], day) do
+          @block.call(day)
+        end
       end
+      safe_join results
     end
 
-    # Generates the link to next and previous months
-    def month_link(text, date, params, opts={})
-      link_to(text, params.merge({:month => date.month, :year => date.year}), opts)
+    def get_options(options, *params)
+      case options
+      when Hash
+        options
+      when String
+        send(options, *params)
+      when Symbol
+        send(options, *params)
+      else
+        options.call(*params) if options.respond_to? :call
+      end
+    end
+
+    def default_options
+      { table: {}, tr: {}, td: {}, }
     end
   end
 end

data/simple_calendar.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Chris Oliver"]
   s.email       = ["excid3@gmail.com"]
   s.homepage    = "https://github.com/excid3/simple_calendar"
-  s.summary     = %q{A simple Rails 3 calendar}
-  s.description = %q{A simple Rails 3 calendar}
+  s.summary     = %q{A simple Rails 3 and Rails 4 calendar}
+  s.description = %q{A simple Rails 3 and Rails 4 calendar}
 
   s.rubyforge_project = "simple_calendar"
 
@@ -18,5 +18,5 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency('rails', '>= 3.0')
+  s.add_dependency 'rails', '>= 3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_calendar
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 1.0.0
 platform: ruby
 authors:
 - Chris Oliver
@@ -24,7 +24,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-description: A simple Rails 3 calendar
+description: A simple Rails 3 and Rails 4 calendar
 email:
 - excid3@gmail.com
 executables: []
@@ -41,9 +41,6 @@ files:
 - lib/simple_calendar/version.rb
 - lib/simple_calendar/view_helpers.rb
 - simple_calendar.gemspec
-- spec/helper.rb
-- spec/simple_calendar_spec.rb
-- spec/support/railtie.rb
 homepage: https://github.com/excid3/simple_calendar
 licenses: []
 metadata: {}
@@ -66,8 +63,5 @@ rubyforge_project: simple_calendar
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: A simple Rails 3 calendar
-test_files:
-- spec/helper.rb
-- spec/simple_calendar_spec.rb
-- spec/support/railtie.rb
+summary: A simple Rails 3 and Rails 4 calendar
+test_files: []

data/spec/helper.rb

@@ -1,24 +0,0 @@
-require 'pathname'
-require 'rubygems'
-require 'bundler'
-require 'pry'
-require 'active_support/all'
-require 'action_view'
-
-root_path = Pathname(__FILE__).dirname.join('..').expand_path
-lib_path  = root_path.join('lib')
-
-Dir[root_path.join("spec/support/*.rb")].each { |f| require f }
-Dir[lib_path.join("simple_calendar/*.rb")].each { |f| require f }
-
-Bundler.setup(:default)
-
-RSpec.configure do |config|
-  config.fail_fast = true
-
-  config.filter_run :focused => true
-  config.alias_example_to :fit, :focused => true
-  config.alias_example_to :xit, :pending => true
-  config.run_all_when_everything_filtered = true
-end
-Time.zone = "UTC"

data/spec/simple_calendar_spec.rb

@@ -1,102 +0,0 @@
-require 'helper'
-
-class View
-  include SimpleCalendar::ViewHelpers
-  include ActionView::Helpers
-  include ActionView::Context
-
-  def raw(argument)
-    argument
-  end
-
-end
-
-describe "SimpleCalendar" do
-  subject { View.new }
-
-  before do
-    subject.stub(:params => {:year => 2013, :month => 5})
-  end
-
-  describe "#calendar" do
-    context "with invalid arguments" do
-      it "should raise an error" do
-        expect { subject.calendar("foo") }.to raise_error(StandardError, /block/)
-      end
-    end
-
-    context "with valid arguments" do
-      it "should draw a calendar" do
-        subject.should_receive(:draw_calendar)
-        subject.calendar("foo") { "test" }
-      end
-
-      it "should not overwrite passed in arguments" do
-        subject.should_receive(:build_range).and_return([2,2,3])
-        subject.should_receive(:draw_calendar)
-        subject.calendar("foo") { "test" }
-      end
-    end
-  end
-
-  describe "#build_range" do
-    it "should return an array representing the days of the month" do
-      selected_month = Date.new(2013, 1)
-      options        = {:start_day => :tuesday}
-      result         = subject.send(:build_range, selected_month, options)
-      result.class.should == Array
-      result.first.class.should == Date
-      result.last.class.should == Date
-    end
-  end
-
-  describe "#draw_calendar" do
-    it "should render a calendar table" do
-      #TODO: refactor draw_calendar to not require so much build up
-      subject.should_receive(:month_header)
-      selected_month = Date.new(2013, 1)
-      month          = []
-      current_date   = Date.new(2013, 1, 14)
-      events         = {}
-      options        = {:start_day => :monday}
-      block          = Proc.new {}
-      subject.send(:draw_calendar, selected_month, month, current_date, events, options, block).should match(/^<table/)
-    end
-  end
-
-  describe "#day_events" do
-    it "should return an array of events for a given day" do
-      date           = Date.new(2013, 1, 14)
-      matching_event = stub(:start_time => Date.new(2013, 1, 14))
-      other_event    = stub(:start_time => Date.new(2013,1,15))
-      events = [matching_event, other_event]
-      subject.send(:day_events, date, events, "start_time").should == [matching_event]
-    end
-  end
-
-  describe "#month_header" do
-    it "should generate html including the month, next and previous month" do
-      subject.should_receive(:month_link).exactly(2)
-      selected_month = Date.new(2013, 1)
-      options = {}
-      subject.send(:month_header, selected_month, options).should match(/^<h2>January 2013<\/h2>/)
-    end
-
-    it "should allow the display_year option to be set to false and not show the year" do
-      subject.should_receive(:month_link).exactly(2)
-      selected_month = Date.new(2014, 1)
-      options = {:dont_display_year => true}
-      str = subject.send(:month_header, selected_month, options)
-      str.should match(/^<h2>January<\/h2>/)
-    end
-
-  end
-
-  describe "#month_link" do
-    it "should return a link" do
-      #TODO: test even needed?
-      subject.should_receive(:link_to)
-      subject.send(:month_link, "previous", Date.new(2013, 1), {})
-    end
-  end
-end

data/spec/support/railtie.rb

@@ -1,9 +0,0 @@
-module SimpleCalendar
-  class Rails
-    class Railtie
-      def self.initializer(object)
-      end
-    end
-  end
-end
-