Question

I have a large class with lots of methods and it’s starting to get a bit unorganized and hard to navigate. I’d like to break it up into modules, where each module is a collection of class and instance methods. Perhaps something like this:

UPDATE: I’ve now realized that this is a pretty poor example. You probably wouldn’t want to move validations or attributes out of the core class.

class Large
  include Validations
  include Attributes
  include BusinessLogic
  include Callbacks
end

After reading Yehuda’s post about Better Ruby Idioms, I’m curious how others are tackling this problem. Here’s the two methods I can think of.

First Method

module Foo
  module Validations
    module ClassMethods
      def bar
        "bar"
      end
    end

    module InstanceMethods
      def baz
        "baz"
      end
    end
  end

  class Large
    extend Validations::ClassMethods
    include Validations::InstanceMethods
  end
end

Second Method

module Foo
  module Validations
    def self.included(base)
      base.extend ClassMethods
    end

    module ClassMethods
      def bar
        "bar"
      end
    end

    def baz
      "baz"
    end
  end

  class Base
    include Validations
  end
end

My questions are:

• Is there a better way to do this?
• How do you get a one-liner module mixin for a set of class/instance methods with the least amount of magic?
• How do you namespace these modules to the base class without namespacing the class itself?
• How do you organize these files?

Answer 1

Breaking a class into modules, while tempting (because it’s so easy in Ruby), is rarely the right answer. I usually regard the temptation to break out modules as the code’s way of telling me it wants to be split into more tightly-focussed classes. A class that’s so big you want to break it into multiple files is pretty much guaranteed to be violating the Single Responsibility Principle.

EDIT: To elaborate a bit on why breaking code into modules is a bad idea: it’s confusing to the reader/maintainer. A class should represent a single tightly-focussed concept. It’s bad enough when you have to scroll hundreds of lines to find the definition of an instance method used at the other end of a long class file. It’s even worse when you come across an instance method call and have to go looking in another file for it.