no need

Jared – so for you, the key to picking a module over a class is the following rule of thumb?

they don’t require initialization and they have no state; they’re just behavior.

This is a great example of how a programmer needs to learn to think differently when dealing with different languages.

I like your second example, and I know it’s purposely simple, but if the difference in behavior is that small, I’d be inclined to use a solution like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Citation
  attr_accessor :format
  
  def initialize(format)
    self.format = format
  end
  
  def to_s
    self.send(format)
  end
  
  def mla
    "MLA format"
  end

  def cms
    "CMS format"
  end
end

puts Citation.new(:mla) => 'MLA format'
puts Citation.new(:cms) => 'CMS format'

Keeping your code as short and simple as possible is pretty important to me. Of course, your example would be better once the differences in behavior are more than just trivial.

Dan,

As much as I try to look for hard and fast rules, I’d only say to assume ‘no initialization. no state. this probably should be a module’. Then take a step back and question your decision.

Tammer,

1. i want each specific formatting code (MLA, CMS) in its own class or module (its own place/file); that way I know right where to look for new features/bug fixes
2. i do not want formatting code along side my Citation code, that’s going to bloat my Citation class
3. i want to be able to add a new format without touching any existing code (OCP). Putting the formatting logic in my Citation class would not allow this because I would have to modify my Citation class

I see your points, but I’m not sure I agree with all of them:

i want each specific formatting code (MLA, CMS) in its own class or module (its own place/file); that way I know right where to look for new features/bug fixes

Having the behavior of a class spread out across a whole set of modules makes it really hard to determine which piece is doing what imho. And I really don’t like having to go hunting through different files to find the piece of code I have to fix.

i want to be able to add a new format without touching any existing code (OCP). Putting the formatting logic in my Citation class would not allow this because I would have to modify my Citation class

I would agree, if the code required a plugin system. And you should definitely always strive to make code externally extensible, but not in the face of readability.

Still, in your example, you’d have to add all of this:

1
2
3
4
5
6
7

def cms
  citation = new
  class << citation
    include CMSFormat
  end
  citation
end

While the example I gave only requires the addition of a single one-line method.

It’s all about thinking in the mindset of the language. When you think in the ruby mindset, you see that methods on an object are just messages being passed around – and that .send() isn’t a hack, but just an easy way to send a message dynamically.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class Citation
  module Format; end
  
    class << self
      def method_missing name, *args
        if name = Citation::Format.constants.find{|c| c.match(/#{name}/i)}
          citation = new
          citation.class.send :include, Citation::Format.const_get(name.to_sym)
          citation
        else
          super
        end
      end
    end
  
  def to_s
    format
  end
end

module Citation::Format::MLA
  def format
    "MLA Format"
  end
end

module Citation::Format::CMS
  def format
    "CMS Format"
  end
end

Now you only have to add a new module to get the new format.

Thanks, jon. Yes that would avoid me having to go back and add another convenience method for constructing a Citation with a particular format (except I think your including the module in the class and not the citation instance)

Tammer, formatting is not a responsibility/concern of the Citation class; forget how simple the implementation of my example format’s are (once again separation of concerns).

D’oh! You’re right. That should be citation.extend, not citation.class.include.

I’m not convinced that putting formatting in Citation violates OCP. It’s open for extension – adding another format. It’s closed for modification – existing functionality doesn’t change. The fact that some other reopening of the class COULD violate OCP doesn’t mean that all reopenings do. Reopening a class is (often) just another way to extend in Ruby.

And to prove it, I will back that opinion up with a Google I-Feel-Lucky search on ocp open-closed ruby>

Architecture Blog

See? Google says so.

generic viagra; cheap viagra online; buy viagra online; buy viagra uk.

DiscountRxPharmacyOnline