cal 0.4.1 → 0.5.0

data/README.md

@@ -20,21 +20,26 @@ Or install it yourself as:
 
 ## Usage
 
+Cal is a simple calendar structure. It **does not** render a calendar. It **does not** handle events.
+
 See the Rails app [https://github.com/austinthecoder/cal-app](https://github.com/austinthecoder/cal-app) for an example.
 
 ### Rails example
 
 ``` ruby
-# in the controller
-- calendar = Cal::MonthlyCalendar.new((params[:date] || Date.current), :start_week_on => :monday)
+# routes
+match 'calendar/:month', :to => 'calendars#show'
+
+# controller
+calendar = Cal::MonthlyCalendar.from_param params[:month], :start_week_on => :monday
 
-# in the view
+# view
 %h3
-  = link_to 'Previous month', url_for(:date => calendar.previous.date)
+  = link_to 'Previous month', calendar_path(calendar.previous)
   |
   = "#{calendar.month} #{calendar.year}"
   |
-  = link_to 'Next month', url_for(:date => calendar.next.date)
+  = link_to 'Next month', calendar_path(calendar.next)
 
 %table
   %thead

data/lib/cal.rb

@@ -6,6 +6,5 @@ module Cal
   autoload :MonthlyCalendar, 'cal/monthly_calendar'
   autoload :Day, 'cal/day'
   autoload :Month, 'cal/month'
-  autoload :Year, 'cal/year'
 
 end

data/lib/cal/month.rb

@@ -1,18 +1,41 @@
 module Cal
   class Month
 
-    def initialize(calendar)
-      @calendar = calendar
+    include Comparable
+
+    def initialize(year, number)
+      @year = year.to_i
+      @number = number.to_i
+    end
+
+    attr_reader :year, :number
+
+    alias_method :to_i, :number
+
+    def <=>(other)
+      date <=> other.send(:date) if other.is_a?(self.class)
     end
 
-    attr_reader :calendar
+    def to_s(*args)
+      date.strftime *args
+    end
 
-    def ==(other)
-      other.is_a?(Month) && other.calendar == calendar
+    def succ
+      self.class.new *(number == 12 ? [(year + 1), 1] : [year, (number + 1)])
     end
 
-    def to_s
-      calendar.date.strftime "%B"
+    def previous
+      self.class.new *(number == 1 ? [(year - 1), 12] : [year, (number - 1)])
+    end
+
+    def to_month
+      self
+    end
+
+  private
+
+    def date
+      @date ||= Date.new year, number
     end
 
   end

data/lib/cal/monthly_calendar.rb

@@ -4,6 +4,8 @@ require 'active_support/core_ext/string/conversions'
 module Cal
   class MonthlyCalendar
 
+    include Comparable
+
     DAY_NAMES = {
       :sunday => 0,
       :monday => 1,
@@ -14,27 +16,50 @@ module Cal
       :saturday => 6
     }
 
-    def initialize(dateable, options = {})
-      @date = dateable.to_date
+    class << self
+      def from_month(month, options = {})
+        month = month.to_month
+        new month.year, month.number, options
+      end
+
+      def from_param(param)
+        year, month_number = if param.present?
+          param.split '-'
+        else
+          now = Date.current
+          [now.year, now.month]
+        end
+        new year, month_number
+      end
+    end
+
+    def initialize(year, month_number, options = {})
       @start_week_on = options[:start_week_on] || :sunday
-      @month = Month.new self
-      @year = Year.new self
+      @month = Month.new year, month_number
     end
 
-    attr_reader :date, :month, :year
+    attr_reader :month
+
+    delegate :year, :to => :month
 
-    def ==(other)
-      other.is_a?(MonthlyCalendar) &&
-        other.date.year == date.year &&
-        other.date.month == date.month
+    def <=>(other)
+      if other.is_a?(MonthlyCalendar) && start_week_on == other.send(:start_week_on)
+        month <=> other.month
+      end
     end
 
     def first_day
-      @first_day ||= Day.new date.beginning_of_month.beginning_of_week(@start_week_on), self
+      @first_day ||= begin
+        date = Date.new(year, month.to_i).beginning_of_month.beginning_of_week(start_week_on)
+        Day.new date, self
+      end
     end
 
     def last_day
-      @last_day ||= Day.new date.end_of_month.end_of_week(@start_week_on), self
+      @last_day ||= begin
+        date = Date.new(year, month.to_i).end_of_month.end_of_week(start_week_on)
+        Day.new date, self
+      end
     end
 
     def days
@@ -46,16 +71,24 @@ module Cal
     end
 
     def previous
-      self.class.new date.prev_month
+      self.class.from_month month.previous, :start_week_on => start_week_on
     end
 
     def next
-      self.class.new date.next_month
+      self.class.from_month month.succ, :start_week_on => start_week_on
     end
 
     def day_names
-      %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].rotate DAY_NAMES[@start_week_on]
+      %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].rotate DAY_NAMES[start_week_on]
     end
 
+    def to_param
+      "#{year}-#{month.to_i}"
+    end
+
+  private
+
+    attr_reader :start_week_on
+
   end
 end

data/lib/cal/version.rb

@@ -1,5 +1,5 @@
 module Cal
 
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 
 end

data/spec/cal/month_spec.rb

@@ -2,33 +2,121 @@ require 'spec_helper'
 
 describe Cal::Month do
 
-  subject { described_class.new @calendar }
+  subject { described_class.new @year, @month_number }
 
-  before { @calendar = OpenStruct.new }
+  before do
+    @year = 2012
+    @month_number = 3
+  end
 
-  describe "==" do
-    it "is true with another month with the same calendar" do
-      (subject == described_class.new(@calendar)).should be_true
+  describe "initialize" do
+    it "coerces the year and month number to integers" do
+      @year = "2012"
+      @month_number = "04"
+      subject.year.should == 2012
+      subject.number.should == 4
     end
+  end
+
+  it { should be_a(Comparable) }
 
-    it "is false with another month with a different calendar" do
-      (subject == described_class.new(Object.new)).should be_false
+  describe "<=>" do
+    it "is nil with a non month" do
+      (subject <=> Object.new).should be_nil
     end
 
+    context "given another month" do
+      before { @other = described_class.new @year, @month_number }
+
+      context "when the other's year is the same" do
+        it "is 0 when the other's month is the same" do
+          (subject <=> @other).should == 0
+        end
+
+        it "is -1 when the other's month is higher" do
+          @month_number = 2
+          (subject <=> @other).should == -1
+        end
+
+        it "is 1 when the other's month is lower" do
+          @month_number = 4
+          (subject <=> @other).should == 1
+        end
+      end
+
+      it "is -1 when the other's year is higher" do
+        @year = 2011
+        (subject <=> @other).should == -1
+      end
+
+      it "is 1 when the other's year is lower" do
+        @year = 2013
+        (subject <=> @other).should == 1
+      end
+    end
+  end
+
+  describe "==" do
     it "is false with a non month" do
       (subject == Object.new).should be_false
     end
-  end
 
-  describe "calendar" do
-    it "is the given calendar" do
-      subject.calendar.should == @calendar
+    context "given another month" do
+      before { @month = described_class.new @year, @month_number }
+
+      it "is true if the comparison is zero" do
+        subject.stub(:<=>) { 0 }
+        (subject == @month).should be_true
+      end
+
+      it "is false if the comparison is not zero" do
+        subject.stub(:<=>) { -1 }
+        (subject == @month).should be_false
+      end
     end
   end
 
+  it { subject.number.should == @month_number }
+
   describe "to_s" do
-    before { @calendar.stub(:date) { Date.new 2012, 3 } }
-    it { subject.to_s.should == 'March' }
+    it "is the result of formatting a date object" do
+      date = Object.new
+      format = Object.new
+      result = Object.new
+      Date.stub(:new) { |*args| date if args == [@year, @month_number] }
+      date.stub(:strftime) { |f| result if f == format }
+      subject.to_s(format).should == result
+    end
+  end
+
+  describe "year" do
+    it "is the given year" do
+      subject.year.should == 2012
+    end
+  end
+
+  describe "succ" do
+    [[2012, 12, 2013, 1], [2012, 1, 2012, 2]].each do |year, month_number, new_year, new_month_number|
+      it "is the next month" do
+        @year = year
+        @month_number = month_number
+        subject.succ.should == described_class.new(new_year, new_month_number)
+      end
+    end
+  end
+
+  describe "previous" do
+    [[2012, 12, 2012, 11], [2012, 1, 2011, 12]].each do |year, month_number, new_year, new_month_number|
+      it "is the previous month" do
+        @year = year
+        @month_number = month_number
+        subject.previous.should == described_class.new(new_year, new_month_number)
+      end
+    end
+  end
+
+  describe "to_month" do
+    it { subject.to_month.should == subject }
   end
 
 end

data/spec/cal/monthly_calendar_spec.rb

@@ -2,160 +2,198 @@ require 'spec_helper'
 
 describe Cal::MonthlyCalendar do
 
-  subject { described_class.new @date, @options }
+  describe "class methods" do
+    subject { described_class }
 
-  before do
-    @date = Date.new 2012, 2
-    @options = {}
-  end
+    describe "from_month" do
+      it "returns a calendar for the month's year and month number" do
+        subject.from_month(Cal::Month.new(2012, 11)).should == subject.new(2012, 11)
+      end
 
-  describe "initialize" do
-    it "raises an error if arg can't be converted to a date" do
-      ['Octember', Object.new, '2012'].each do |obj|
-        expect { described_class.new obj }.to raise_error
+      it "raises an error without something that can be converted to a month" do
+        [nil, Object.new].each do |object|
+          expect { subject.from_month(object) }.to raise_error(NoMethodError)
+        end
       end
     end
 
-    it "doesn't raise an error if arg can be converted to a date" do
-      [Date.current, Date.new(2012, 1, 15), '2012-02-24'].each do |obj|
-        expect { described_class.new obj }.to_not raise_error
+    describe "from_param" do
+      it "is the calendar for the given param" do
+        calendar = subject.new 2012, 5
+        subject.from_param(calendar.to_param).should == calendar
       end
-    end
-  end
 
-  describe "date" do
-    it "is the given date" do
-      subject.date.should == @date
+      context "with a blank param" do
+        it "returns a calendar for the current year and month" do
+          [' ', nil].each do |param|
+            date = Date.current
+            subject.from_param(param).should == subject.new(date.year, date.month)
+          end
+        end
+      end
     end
   end
 
-  describe "==" do
-    it "is true with another monthly calendar in the same month and year" do
-      calendar = described_class.new Date.new(@date.year, @date.month, (@date.day + 1))
-      (subject == calendar).should be_true
-    end
+  describe "instance methods" do
+    subject { described_class.new @year, @month, @options }
 
-    it "is false with another monthly calendar with a different month" do
-      calendar = described_class.new Date.new(@date.year, (@date.month + 1), @date.day)
-      (subject == calendar).should be_false
+    before do
+      @year = 2012
+      @month = 2
+      @options = {}
     end
 
-    it "is false with another monthly calendar with a different year" do
-      calendar = described_class.new Date.new((@date.year + 1), @date.month, @date.day)
-      (subject == calendar).should be_false
-    end
+    it { should be_a(Comparable) }
 
-    it "is false with a non monthly calendar" do
-      (subject == Object.new).should be_false
+    describe "initialize" do
+      it "coerces the year and month number to integers" do
+        @year = "2012"
+        @month = "04"
+        subject.should == described_class.new(2012, 4)
+      end
     end
-  end
 
-  describe "month" do
-    it { subject.month.should == Cal::Month.new(subject) }
-  end
+    describe "<=>" do
+      it "is nil with a non monthly calendar" do
+        (subject <=> Object.new).should be_nil
+      end
 
-  describe "year" do
-    it { subject.year.should == Cal::Year.new(subject) }
-  end
+      it "is nil with a non monthly calendar" do
+        (subject <=> Object.new).should be_nil
+      end
+
+      context "given another monthly calendar" do
+        before { @other = described_class.new @year, @month, @options }
 
-  describe "first_day" do
-    before { @date = Date.new 2012, 2, 23 }
-
-    [
-      [:monday, [1, 30]],
-      [:tuesday, [1, 31]],
-      [:wednesday, [2, 1]],
-      [:thursday, [1, 26]],
-      [:friday, [1, 27]],
-      [:saturday, [1, 28]]
-    ].each do |weekday, month_day|
-      context "when the weekday is set to start on #{weekday}" do
-        before { @options[:start_week_on] = weekday }
-        it "is the first viewable day on the calendar" do
-          subject.first_day.should == Cal::Day.new(Date.new(2012, *month_day), subject)
+        it "is nil when the other's start day is different" do
+          @options[:start_week_on] = :tuesday
+          (subject <=> @other).should be_nil
+        end
+
+        it "is the result of comparing the months when the other's start day is the same" do
+          result = Object.new
+          subject.month.stub(:<=>) { |m| result if m == @other.month }
+          (subject <=> @other).should == result
         end
       end
     end
 
-    it "is the first viewable day on the calendar, using sunday as the default start day" do
-      subject.first_day.should == Cal::Day.new(Date.new(2012, 1, 29), subject)
+    describe "month" do
+      it { subject.month.should == Cal::Month.new(@year, @month) }
+    end
+
+    describe "year" do
+      it { subject.year.should == @year }
     end
-  end
 
-  describe "last_day" do
-    before { @date = Date.new 2012, 2, 23 }
-
-    [
-      [:monday, [3, 4]],
-      [:tuesday, [3, 5]],
-      [:wednesday, [3, 6]],
-      [:thursday, [2, 29]],
-      [:friday, [3, 1]],
-      [:saturday, [3, 2]]
-    ].each do |weekday, month_day|
-      context "when the weekday is set to start on #{weekday}" do
-        before { @options[:start_week_on] = weekday }
-        it "is the last viewable day on the calendar" do
-          subject.last_day.should == Cal::Day.new(Date.new(2012, *month_day), subject)
+    describe "first_day" do
+      before { @year, @month = 2012, 2 }
+
+      [
+        [:monday, [1, 30]],
+        [:tuesday, [1, 31]],
+        [:wednesday, [2, 1]],
+        [:thursday, [1, 26]],
+        [:friday, [1, 27]],
+        [:saturday, [1, 28]]
+      ].each do |weekday, month_day|
+        context "when the weekday is set to start on #{weekday}" do
+          before { @options[:start_week_on] = weekday }
+          it "is the first viewable day on the calendar" do
+            subject.first_day.should == Cal::Day.new(Date.new(2012, *month_day), subject)
+          end
         end
       end
+
+      it "is the first viewable day on the calendar, using sunday as the default start day" do
+        subject.first_day.should == Cal::Day.new(Date.new(2012, 1, 29), subject)
+      end
     end
 
-    it "is the last viewable day on the calendar, using sunday as the default start day" do
-      subject.last_day.should == Cal::Day.new(Date.new(2012, 3, 3), subject)
+    describe "last_day" do
+      before { @year, @month = 2012, 2 }
+
+      [
+        [:monday, [3, 4]],
+        [:tuesday, [3, 5]],
+        [:wednesday, [3, 6]],
+        [:thursday, [2, 29]],
+        [:friday, [3, 1]],
+        [:saturday, [3, 2]]
+      ].each do |weekday, month_day|
+        context "when the weekday is set to start on #{weekday}" do
+          before { @options[:start_week_on] = weekday }
+          it "is the last viewable day on the calendar" do
+            subject.last_day.should == Cal::Day.new(Date.new(2012, *month_day), subject)
+          end
+        end
+      end
+
+      it "is the last viewable day on the calendar, using sunday as the default start day" do
+        subject.last_day.should == Cal::Day.new(Date.new(2012, 3, 3), subject)
+      end
     end
-  end
 
-  describe "days" do
-    it "is a range of the first day to the last day" do
-      @date = Date.new 2012, 2, 23
-      first_day = Cal::Day.new Date.new(2012, 1, 29), subject
-      last_day = Cal::Day.new Date.new(2012, 3, 3), subject
-      subject.days.should == (first_day..last_day)
+    describe "days" do
+      it "is a range of the first day to the last day" do
+        @year, @month = 2012, 2
+        first_day = Cal::Day.new Date.new(2012, 1, 29), subject
+        last_day = Cal::Day.new Date.new(2012, 3, 3), subject
+        subject.days.should == (first_day..last_day)
+      end
     end
-  end
 
-  describe "weeks" do
-    it "an array of the days in groups of 7" do
-      @date = Date.parse "2012-02-23"
-      subject.weeks.should == [
-        %w[01-29 01-30 01-31 02-01 02-02 02-03 02-04].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject },
-        %w[02-05 02-06 02-07 02-08 02-09 02-10 02-11].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject },
-        %w[02-12 02-13 02-14 02-15 02-16 02-17 02-18].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject },
-        %w[02-19 02-20 02-21 02-22 02-23 02-24 02-25].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject },
-        %w[02-26 02-27 02-28 02-29 03-01 03-02 03-03].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject }
-      ]
+    describe "weeks" do
+      it "an array of the days in groups of 7" do
+        @year, @month = 2012, 2
+        subject.weeks.should == [
+          %w[01-29 01-30 01-31 02-01 02-02 02-03 02-04].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject },
+          %w[02-05 02-06 02-07 02-08 02-09 02-10 02-11].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject },
+          %w[02-12 02-13 02-14 02-15 02-16 02-17 02-18].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject },
+          %w[02-19 02-20 02-21 02-22 02-23 02-24 02-25].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject },
+          %w[02-26 02-27 02-28 02-29 03-01 03-02 03-03].map { |s| Cal::Day.new Date.parse("2012-#{s}"), subject }
+        ]
+      end
     end
-  end
 
-  describe "previous" do
-    it "returns the calendar for the previous month" do
-      subject.previous.should == described_class.new(@date.prev_month)
+    describe "previous" do
+      it "returns the calendar for the previous month" do
+        @options[:start_week_on] = :wednesday
+        subject.previous.should == described_class.new(@year, (@month - 1), @options)
+      end
     end
-  end
 
-  describe "next" do
-    it "returns the calendar for the next month" do
-      subject.next.should == described_class.new(@date.next_month)
+    describe "next" do
+      it "returns the calendar for the next month" do
+        @options[:start_week_on] = :wednesday
+        subject.next.should == described_class.new(@year, (@month + 1), @options)
+      end
     end
-  end
 
-  describe "day_names" do
-    it "defaults to sunday through saturday" do
-      subject.day_names.should == %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday]
+    describe "day_names" do
+      it "defaults to sunday through saturday" do
+        subject.day_names.should == %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday]
+      end
+
+      [
+        %w[Monday Tuesday Wednesday Thursday Friday Saturday Sunday],
+        %w[Tuesday Wednesday Thursday Friday Saturday Sunday Monday],
+        %w[Wednesday Thursday Friday Saturday Sunday Monday Tuesday],
+        %w[Thursday Friday Saturday Sunday Monday Tuesday Wednesday],
+        %w[Friday Saturday Sunday Monday Tuesday Wednesday Thursday],
+        %w[Saturday Sunday Monday Tuesday Wednesday Thursday Friday]
+      ].each do |day_names|
+        it "is #{day_names[0]} through #{day_names[6]} when the weekday is set to start on #{day_names[0]}" do
+          @options[:start_week_on] = day_names[0].downcase.to_sym
+          subject.day_names.should == day_names
+        end
+      end
     end
 
-    [
-      %w[Monday Tuesday Wednesday Thursday Friday Saturday Sunday],
-      %w[Tuesday Wednesday Thursday Friday Saturday Sunday Monday],
-      %w[Wednesday Thursday Friday Saturday Sunday Monday Tuesday],
-      %w[Thursday Friday Saturday Sunday Monday Tuesday Wednesday],
-      %w[Friday Saturday Sunday Monday Tuesday Wednesday Thursday],
-      %w[Saturday Sunday Monday Tuesday Wednesday Thursday Friday]
-    ].each do |day_names|
-      it "is #{day_names[0]} through #{day_names[6]} when the weekday is set to start on #{day_names[0]}" do
-        @options[:start_week_on] = day_names[0].downcase.to_sym
-        subject.day_names.should == day_names
+    describe "to_param" do
+      it "is the year and month string" do
+        @year, @month = 2012, 12
+        subject.to_param.should == "2012-12"
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cal
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-09 00:00:00.000000000 Z
+date: 2012-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -62,11 +62,9 @@ files:
 - lib/cal/month.rb
 - lib/cal/monthly_calendar.rb
 - lib/cal/version.rb
-- lib/cal/year.rb
 - spec/cal/day_spec.rb
 - spec/cal/month_spec.rb
 - spec/cal/monthly_calendar_spec.rb
-- spec/cal/year_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/austinthecoder/cal
 licenses: []
@@ -96,5 +94,4 @@ test_files:
 - spec/cal/day_spec.rb
 - spec/cal/month_spec.rb
 - spec/cal/monthly_calendar_spec.rb
-- spec/cal/year_spec.rb
 - spec/spec_helper.rb

data/lib/cal/year.rb

@@ -1,19 +0,0 @@
-module Cal
-  class Year
-
-    def initialize(calendar)
-      @calendar = calendar
-    end
-
-    attr_reader :calendar
-
-    def ==(other)
-      other.is_a?(Year) && other.calendar == calendar
-    end
-
-    def to_s
-      calendar.date.strftime "%Y"
-    end
-
-  end
-end

data/spec/cal/year_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Cal::Year do
-
-  subject { described_class.new @calendar }
-
-  before { @calendar = OpenStruct.new }
-
-  describe "==" do
-    it "is true with another year with the same calendar" do
-      (subject == described_class.new(@calendar)).should be_true
-    end
-
-    it "is false with another year with a different calendar" do
-      (subject == described_class.new(Object.new)).should be_false
-    end
-
-    it "is false with a non year" do
-      (subject == Object.new).should be_false
-    end
-  end
-
-  describe "calendar" do
-    it "is the given calendar" do
-      subject.calendar.should == @calendar
-    end
-  end
-
-  describe "to_s" do
-    before { @calendar.date = Date.new 1983 }
-    it { subject.to_s.should == '1983' }
-  end
-
-end