ruby - 如何在 Ruby 中重构单例方法？

Question

目前我有如下代码(有所简化)。最终，我添加了越来越多的新类，如 D1/D2，我认为是时候进行一些重构以使其更优雅了。当然，目标是使添加新类 Dx 使用尽可能少的重复代码。至少，在单例方法 Dx.import 中调用 FileImporter.import 的重复部分应该被排除。

module FileImporter
  def self.import(main_window, viewers)
    ...
    importer = yield file  # delegate to D1/D2 for preparing the importer object
    ...
  end
end

class D1
  def self.import(main_window)
    viewers = [:V11, ]  # D1 specific viewers
    FileImporter.import(main_window, viewers) do |file|
      importer = self.new(file)
      ...  # D1 specific handling of importer
      return importer
    end
  end
end

class D2
  def self.import(main_window)
    viewers = [:V21,:v22, ]  # D2 specific viewers
    FileImporter.import(main_window, viewers) do |file|
      importer = self.new(file)
      ...  # D2 specific handling of importer
      return importer
    end
  end
end

# client code calls D1.import(...) or D2.import(...)

本质上，FileImporter.import 是通用部分，Dx.import 是变体。我不确定如何重构这些单例方法。执行此操作的常见 Ruby 方法是什么？

更新:(在上面的代码中添加了一些注释，希望能使我的意图更清楚......)

最初，我省略了我认为不重要的代码以避免混淆。我应该提到上面的代码也是重构类 D1 和 D2 的结果(通过将公共(public)部分移出并移入模块 FileImporter)。 D1.import 和 D2.import 的目的主要是创建适当类的对象(并且可能在从 block 返回之前进行一些特定于类的处理)。 FileImporter.import 主要是通用逻辑，其中在某些时候会产生特定的类来生成导入器对象。

我觉得类D1和D2看起来很相似，应该可以进一步重构它们。例如，它们都调用 FileImporter.import 来提供一个 block ，在该 block 中都创建了一个自身的对象。

解决方案:最初我没有意识到您可以通过从派生类的相应单例方法中调用 super 来调用基类的单例方法。那确实是我遇到的主要问题，并且无法走那条路。所以我接受了@makevoid 的回答，因为它确实使创建新的派生类变得更加容易。

使用公共(public)基类是一种优雅的重构解决方案，但一个问题是所有新的派生类都已经用完了一个基类配额。我来到了这个类宏方法，它从派生类的角度提供了更简洁的结果。

module FileImporter
  def self.included(mod)
    mod.extend ClassMethods
  end

  module ClassMethods
    def importer_viewer(*viewers, &blk)
      @viewers = viewers
      @blk = blk

      class << self
        def import(main_window)
          if @blk.nil?
            FileImporter.import(main_window, @viewers) do |file|
              self.new(file)
            end
          else
            FileImporter.import(main_window, @viewers, &@blk)
          end      
        end
      end
    end
  end

  def self.import(main_window, viewers, multi=true)
    ...
    importer = yield file  # delegate to D1/D2 for preparing the importer object
    ...
  end
end

class D1
  include FileImporter
  importer_viewer [:V11, ] do
    ...  # D1 specific handling of importer
  end
end

class D2
  include FileImporter
  importer_viewer [:V21,:v22, ] do
    ...  # D2 specific handling of importer
  end
end

Answer 1

也许这不是最好的解决方案，但乍一看 Dx 类似乎共享相同的行为，因此使用具有 self.import 方法的 C 类对它们进行子类化，该方法使用 block 来接受一些其他代码。或者也可以通过包含一个模块来完成。

无论如何，像这样的东西应该可以工作(对于较短的名称感到抱歉，但对原型(prototype)设计很有用)。另请注意，我将 FileImporter.import 方法名称更改为另一个以避免误解 请注意，我还没有测试代码:)

module F
  def self.fimport(something)
    yield "file"
  end
end


class C   
  include F 

  def initialize(f)

  end

  def self.import(something, &block)
    F.fimport(something) { |f|
      d = self.new(f)
      block.call
      d
    }
  end
end


class D1 < C
  def self.import(something)
    super(something){
      puts something
    }
  end
end


class D2 < C
  def self.import(something)
    super(something){
      puts something
    }
  end
end

p D1.import("a")
p D2.import("b")

#=> a
#=> #<D1:0x100163068>
#=> b
#=> #<D2:0x100162e88>