leap.rb cant find modulo error

Question

Wondering if anyone can see why I cant call .modulo. I feel like its something like I have to call Math in the class but I Im not sure thats the case.

git: https://github.com/jbasalone/ja/tree/master/ruby/exercism.io/leap

the error:

test_leap_year(YearTest):
    NoMethodError: undefined method `modulo' for nil:NilClass
    /Users/jennyb/ja/ja/ruby/exercism.io/leap/year.rb:26:in `divbyfour?'
    /Users/jennyb/ja/ja/ruby/exercism.io/leap/year.rb:17:in `leap?'
    leap_test.rb:6:in `test_leap_year'

This is my code:

class Year

    def initialize(theyear)
        @theyear = theyear
    end
class << self

    attr_reader :theyear

    def initialize(theyear)
        @theyear = theyear
    end

    def leap?(theyear)
        divbyfour? && !acentury? || bcentury?
    end
    #private

    def acentury?
        theyear.modulo 100 == 0
    end

    def divbyfour?
        theyear.modulo 4 == 0
    end

    def bcentury?
        theyear.modulo 400 == 0 
    end
    end
    end

And this is the test I run against it:

require 'minitest/autorun'
require_relative 'year'

class YearTest < MiniTest::Unit::TestCase
   def test_leap_year
     assert Year.leap?(1996)
   end

  def test_non_leap_year
    skip
    refute Year.leap?(1997)
  end

  def test_non_leap_even_year
    skip
    refute Year.leap?(1998)
  end

  def test_century
    skip
    refute Year.leap?(1900)
  end

  def test_fourth_century
    skip
    assert Year.leap?(2400)
  end
end

Answer 1

In divbyfour method you call modulo on theyear variable which doesn't exist.

Here's a code that fixes your problem.

class Year
  attr_reader :theyear

  def initialize(theyear)
    @theyear = theyear
  end

  def leap?
    divbyfour? && !acentury? || bcentury?
  end

  def acentury?
    theyear.modulo(100) == 0
  end

  def divbyfour?
    theyear.modulo(4) == 0
  end

  def bcentury?
    theyear.modulo(400) == 0
  end
end

Example:

>> year = Year.new 2014
=> #<Year:0xb8eb15b4 @theyear=2014>
>> year.leap?
=> false

What I did:

• Removed include Math. Math doesn't implement modulo method, so it's not required here, you don't need it anyway – Fixnum implements its own modulo method.
• Removed class << self line. Read up on what it does. Also, initialize should be an instance method, not a class one. Here's a good post on differences between instance and class methods in Ruby.
• Added parentheses in calls to modulo. theyear.modulo 100 == 0 is an equivalent to theyear.modulo(100 == 0) and what you actually want is theyear.modulo(100) == 0.

If you have time, check out Ruby Koans – it's a great way to learn Ruby and its idioms.

Answer 2

This works for me:

class Year

    attr_accessor :theyear

    def initialize(theyear)
        @theyear = theyear
    end

    def leap?
        divbyfour? && !acentury? || bcentury?
    end
    #private

    def acentury?
        theyear.modulo(100) == 0
    end

    def divbyfour?
        theyear.modulo(4) == 0
    end

    def bcentury?
        theyear.modulo(400) == 0 
    end
end

And then you call it with:

y = Year.new(1995)
y.leap?

Alternatively you can use it like this:

class Year

    def self.leap?(year)
        @theyear = year
        divbyfour? && !acentury? || bcentury?
    end

    def self.theyear
      @theyear
    end
    #private

    def self.acentury?
        theyear.modulo(100) == 0
    end

    def self.divbyfour?
        theyear.modulo(4) == 0
    end

    def self.bcentury?
        theyear.modulo(400) == 0 
    end
end

And then you don't need to initialize the Year class.

Year.leap?(1995)
=> false