Attualmente sto lavorando con un codice che IMO ha abusato delle funzioni di mixy di Ruby. Dato che sono nuovo al rubino, mi chiedo se MO in IMO sia corretto o meno.

La mia domanda principale è ciò che ha più senso (e se ci sono delle differenze tecniche tra di loro):

per es.

1

per creare classi di helper singleton (o moduli con metodi di classe) per mantenere tutte le mie funzioni di "aiuto".

module Helper
  def foo(); p 'foo'; end  # instance method
end

class User
  include Helper     # foo() is now a method of User

  def initialize()
    foo()            # included, invoked on User class object
  end

end

------- O -------

2

crea moduli di mixin che contengono queste funzioni e include li ovunque io abbia bisogno di loro.

module Helper
  def self.foo(); p 'foo'; end  # class method
end

class User

  def initialize()
    Helper.foo()            # Invoked on Helper module object
  end

end

Un esempio del modo in cui è stato abusato nel mio caso:

module ComplexMathPerformer
  def perform_complex_math(); p 'perform_complex_math()'; end
end

module Renderer
  def render_3d_object()
    perform_complex_math() # from ComplexMathPerformer, which is NOT included here.
  end
end

module Game
  include ComplexMathPerformer
  include Renderer

  def play()
    render_3d_object()
  end

end

Questo codice funziona perché Game include sia Renderer che ComplexMathPerformer . Ma è un incubo per chi guarda ComplexMathPerformer e cerca di capire dove diavolo è definito foo() e come è accessibile in ComplexMathPerformer .

Logicamente ha più senso include ComplexMathPerformer , ma viene saltato perché Game include già ComplexMathPerformer (per i propri scopi). Ne fanno un casino.