Rubyのリファクタリングでイケてないコードを美しいオブジェクト指向設計のコードへ改良するための方法

Rubyのリファクタリングでオブジェクト指向設計に沿った美しいコードになるまでの方法を書いた。

コードの元ネタはBen Orenstein氏のリファクタリングで、そこに私なりの解説と追加コードを加えた。
[Ben Orenstein - Refactoring from good to great](https://github.com/r00k/refactoring-good-to-great)

このリファクタリングは大きく分けて３段階。

1. [「イケてない」から「マシ」にする](http://qiita.com/jabba/items/e169adb2f33532c119cf#1-%E3%82%A4%E3%82%B1%E3%81%A6%E3%81%AA%E3%81%84%E3%81%8B%E3%82%89%E3%83%9E%E3%82%B7%E3%81%AB%E3%81%99%E3%82%8B%E3%81%9F%E3%82%81%E3%81%AE%E3%83%AA%E3%83%95%E3%82%A1%E3%82%AF%E3%82%BF%E3%83%AA%E3%83%B3%E3%82%B0)
2. [「マシ」から「いいね」にする](http://qiita.com/jabba/items/e169adb2f33532c119cf#2%E3%83%9E%E3%82%B7%E3%81%8B%E3%82%89%E3%81%84%E3%81%84%E3%81%AD%E3%81%AB%E3%81%99%E3%82%8B%E3%81%9F%E3%82%81%E3%81%AE%E3%83%AA%E3%83%95%E3%82%A1%E3%82%AF%E3%82%BF%E3%83%AA%E3%83%B3%E3%82%B0)
3. [「いいね」から「スゲーいいね」にする](http://qiita.com/jabba/items/e169adb2f33532c119cf#%EF%BC%93%E3%81%84%E3%81%84%E3%81%AD%E3%81%8B%E3%82%89%E3%82%B9%E3%82%B2%E3%83%BC%E3%81%84%E3%81%84%E3%81%AD%E3%81%AB%E3%81%99%E3%82%8B%E3%81%9F%E3%82%81%E3%81%AE%E3%83%AA%E3%83%95%E3%82%A1%E3%82%AF%E3%82%BF%E3%83%AA%E3%83%B3%E3%82%B0)

## イケてないコード
まず以下にあるのがイケてないコード。一応動くし、テストもパスしている。でもそのコード品質は平均よりちょっと下という設定。

【範囲を指定してその期間の売上総合計を出すコード】

```rb
class OrdersReport
  def initialize(orders, start_date, end_date)
    @orders = orders
    @start_date = start_date
    @end_date = end_date
  end

  def total_sales_within_date_range
    orders_within_range = []
    @orders.each do |order|
      if order.placed_at >= @start_date && order.placed_at <= @end_date
        orders_within_range << order
      end
    end

    sum = 0
    orders_within_range.each do |order|
      sum += order.amount
    end
    sum
  end
end

class Order < OpenStruct
end
```

RSpecテストコード。

```rb
require 'spec_helper'

describe OrdersReport do
  describe '#total_sales_within_date_range' do
    it 'returns total sales in range' do
      order_within_range1 = Order.new(amount: 5,
                                      placed_at: Date.new(2016, 10, 10))
      order_within_range2 = Order.new(amount: 10,
                                      placed_at: Date.new(2016, 10, 15))
      order_out_of_range = Order.new(amount: 6,
                                     placed_at: Date.new(2016, 1, 1))
      orders = [order_within_range1, order_within_range2, order_out_of_range]

      start_date = Date.new(2016, 10, 1)
      end_date = Date.new(2016, 10, 31)

      expect(OrdersReport.
             new(orders, start_date, end_date).
             total_sales_within_date_range).to eq(15)
    end
  end
end
```

ここからリファクタリングを解説していく。

## コードがやってることの解説

コードがやってることの解説。あくまでリファクタリングなので「やってること」は変化しないし、常にテストはパスするべき。

```rb
class OrdersReport
  def initialize(orders, start_date, end_date)
    @orders = orders
    @start_date = start_date
    @end_date = end_date
  end
```
まずinitializeでそれぞれの入力値をインスタンス変数に保存する。
　

```rb
def total_sales_within_date_range
```
読んで字のごとく total_sales_within_date_rangeはstart_dateからend_dateの範囲内の売上の合計を返すメソッド。
　

```rb
    orders_within_range = []
    @orders.each do |order|
      if order.placed_at >= @start_date && order.placed_at <= @end_date
        orders_within_range << order
      end
    end
```
orders_within_rangeという空のArrayを作る。
@ ordersをeachでひとつひとつ確認し、そのorderがstart_dateからend_dateの範囲内であればArrayに入れる。
この処理によって orders_within_rangeに範囲内のorderが格納される。
　

```rb
    sum = 0
    orders_within_range.each do |order|
      sum += order.amount
    end
    sum
```
sumに初期値の０を入れる。
 orders_within_rangeをeachで回してorderのamountを全てsumに入れて足していく。
sum（売上の合計値）を返す。

# 1. 「イケてない」から「マシ」にするためのリファクタリング

Rubyに装備されいるステキなやり方がほとんど使われておらず、ひたすらeachで回されている。これを適した方法に変える。そうすることで少ないコード行で実装でき、かつ可読性も上がる。

まずorders_within_rangeに範囲内のorderを格納している処理を変更する。
【変更前】

```rb
    orders_within_range = []
    @orders.each do |order|
      if order.placed_at >= @start_date && order.placed_at <= @end_date
        orders_within_range << order
      end
    end
```

ある条件に合えばそれを取り出す処理はselectで可能になる。
<a href="http://ruby-doc.org/core-2.3.1/Enumerable.html#method-i-select">Ruby - selectのドキュメント</a>

上記の処理は次のように置き換えられる。
【変更後】

```rb
    orders_within_range = @orders.select do |order|
      order.placed_at >= @start_date && order.placed_at <= @end_date
    end
```
こうすることで「おおselectか。範囲内のorderを選んで(select)いるんだな」と直感的に理解できる。いちいち頭の中でifの条件があって、、と考えなくてすむ。ちなみにselectの戻り値はArray。
　
次がeachで回して売上合計を出す処理。
【変更前】

```rb
    sum = 0
    orders_within_range.each do |order|
      sum += order.amount
    end
    sum
```
sumの宣言などがあってやたらと行数が長い。基本的に１つのメソッドは５行以内にするべき。元のコードは１３行もある。当面はとにかく行数を短縮することだけを考えてリファクタリングしてもいい。ここで使えるのはinject。
<a href="http://ruby-doc.org/core-2.3.1/Enumerable.html#method-i-inject">Ruby - injectのドキュメント</a>
injectは初期値を設定して中身をぐるぐる回して、それらの結果を返してくれる。
このサイトですごく分かりやすく説明されている。
[ruby の inject をわかりやすく説明してみる](http://kenkiti.hatenadiary.jp/entry/20090114/ruby_inject)

injectを使って変更したコードがこれ
【変更後】

```rb
    orders_within_range.inject(0) do |sum, order|
      sum + order.amount
    end
```
injectがsumの初期値である0を設定し、その後ループの中で順次sum + order.amountを実行して総合計を出している。sumの初期値設定や返り値がinjectにしたことで行数が減ってスッキリした。
　
次にinjectループの中で「sum + order.amount」とやっているのはmapのブロック付きメソッド呼び出しで代用できる。map(&:amount)のような書き方はある程度Rubyのコードを読んだことがあれば馴染みがあると思う。

mapのブロック付きメソッド呼び出しの詳しい解説はここ。
[なぜRubyでブロック付き引数を持つメソッドの引数として&:upcaseみたいな値を渡せるのか](http://blog.mah-lab.com/2014/05/19/ruby-block-proc-arguments/)

【変更後】

```rb
    orders_within_range.map(&:amount).inject(0) do |sum, amount|
      sum + amount
    end
```
計算式がsum + amountだけになってスッキリした。
　
これまでの変更点を全て反映した全体像がこれ。
【変更後】

```rb
class OrdersReport
  def initialize(orders, start_date, end_date)
    @orders = orders
    @start_date = start_date
    @end_date = end_date
  end

  def total_sales_within_date_range
    orders_within_range = @orders.select do |order|
      order.placed_at >= @start_date && order.placed_at <= @end_date
    end

    orders_within_range.map(&:amount).inject(0) do |sum, amount|
      sum + amount
    end
  end
end

class Order < OpenStruct
end
```

多少は行数が減って少しだけ可読性も上がったので一応は「マシ」と言えるレベルになったと思う。
とはいってもまだまだそれは「マシ」レベルであって変更されるべき点は多くある。


# 2.「マシ」から「いいね」にするためのリファクタリング

今回の変更は主にはオブジェクト指向設計の考え方によるリファクタリングになる。

まずはorders_within_rangeをprivateメソッドにして外に出してしまうことにする。メソッド名はそのままorders_within_rangeとした。変更後はこのようになる。
【変更後】

```rb
class OrdersReport
  def initialize(orders, start_date, end_date)
    @orders = orders
    @start_date = start_date
    @end_date = end_date
  end

  def total_sales_within_date_range
    orders_within_range.map(&:amount).inject(0) do |sum, amount|
      sum + amount
    end
  end

  private

  def orders_within_range
    @orders.select do |order|
      order.placed_at >= @start_date && order.placed_at <= @end_date
    end
  end
end

class Order < OpenStruct
end
```

orders_within_rangeが別メソッドになってprivateになっただけ。カット＆ペーストで一瞬で終わってしまうような変更。ただそれでも意味はおおいにある。理由は３つ。

第一にメソッドの行数が変更前はtotal_sales_within_date_rangeが６行だったのが
変更後はtotal_sales_within_date_rangeが３行、orders_within_rangeが３行になった。ひとつのメソッドに６行あるよりも、２つのメソッドに３行ずつの方がいい。メソッドの行数が長くなるほど可読性が低くなり、単一責任の法則がやぶられてしまう。実際、変更前の６行のtotal_sales_within_date_rangeは単一責任の原則からはみ出ていた。

第二にメソッドを分けることで再利用が可能になる。変更前のぐちゃっと６行ある状態ではどうしても再利用なんてできなかった。メソッドを切り分けることでorders_within_rangeなんかの再利用性が上がった。

第三は可読性。変更後のコードでは読む際に上から順にinitialize、total_sales_within_date_rangeと読んで、その時に「orders_within_rangeはprivateメソッドなのか」と分かる。そこでもし詳しくメソッドの中身を見たければその中を見ればいい。orders_within_rangeという名前から処理内容は明らかで中身をそこまで詳しくみなくてもいい、と考えたならそのままtotal_sales_within_date_rangeを読み続けることができる。
つまりprivateメソッドに切り分けることでそのメソッドは「詳しく見る必要がなければ読み飛ばしてもOk」という意図を示すことができる。

次に変更すべきはprivateメソッドの中
【変更前】

```rb
  def orders_within_range
    @orders.select do |order|
      order.placed_at >= @start_date && order.placed_at <= @end_date
    end
  end
```

これは[「聞くな、言え」の法則](http://tango-ruby.hatenablog.com/entry/2015/09/12/232135)に反している。
この法則の詳細はこちら。
[「聞くな、言え」の法則 - Ruby on Railsのビシバシはぁはぁ日記](http://tango-ruby.hatenablog.com/entry/2015/09/12/232135)
この法則をカンタンに説明するとオブジェクトやメソッドにメッセージを渡す時に「このメッセージは渡してもいいでしょうかね？」と聞いてから渡すのではなく、ただ「ほらよ。メッセージだ。受け取れ」と言うだけで渡す方が優れている、という法則。

ここではselectの中でいちいちorder.placed_atが範囲内に入っているかどうかを「聞いている」からよくない。これを「言うだけ」に変更するとこうなる。

【変更後】

```rb
  def orders_within_range
    @orders.select do |order|
      order.placed_between?(@start_date, @end_date)
    end
  end
```

こうすることでただメッセージをorder.placed_between?に投げているだけの処理になる。placed_between?の最後に「？」があるから聞いているように見えるかもしれないが、言いたいことはそこじゃない。条件式を入れて判断せずにメッセージを投げているだけかどうかがポイント。

当然ながらこの変更に伴ってplaced_between?の処理を追加する必要が出てくる。placed_between?を追加した後の全体像がこちら
【変更後の全体像】

```rb
class OrdersReport
  def initialize(orders, start_date, end_date)
    @orders = orders
    @start_date = start_date
    @end_date = end_date
  end

  def total_sales_within_date_range
    orders_within_range.map(&:amount).inject(0) do |sum, amount|
      sum + amount
    end
  end

  private

  def orders_within_range
    @orders.select do |order|
      order.placed_between?(@start_date, @end_date)
    end
  end
end

class Order < OpenStruct
  def placed_between?(start_date, end_date)
    placed_at >= start_date && placed_at <= end_date
  end
end
```

これで少し良くなったようだが、新たな問題も出てきた。コード全体を見渡すとあちこちにstart_date, end_dateを引数として使われている。このコードの処理にはstart_dateとend_dateを毎回入れなければならない。それで可読性と再利用性が下がってしまっている。このコードは再利用しようとするエンジニアに「必ずstart_dateとend_dateで範囲を指定しろよ」と強制しているが明示はしていない。「強制しているが明示はしていない」というのがよくないサイン。

start_date, end_dateというものは常にペアで、どちらかひとつでは成り立たない。なのでそれらをひとまとめにしてしまうのが次にするべき変更。

RubyにはStructというカンタンにデータ構造を定義できるクラスが用意されている。
<a href="http://ruby-doc.org/core-2.2.0/Struct.html">Ruby - Struckのドキュメント</a>

Structを使えば以下のように範囲指定するクラスが定義できる。名前はDateRangeとした。

```rb
class DateRange < Struct.new(:start_date, :end_date)
end
```

このDateRangeを使うためにまずはテストコードを修正する。
【変更後のテストコード】

```rb
require 'spec_helper'

describe OrdersReport do
  describe '#total_sales_within_date_range' do
    it 'returns total sales in range' do
      order_within_range1 = Order.new(amount: 5,
                                      placed_at: Date.new(2016, 10, 10))
      order_within_range2 = Order.new(amount: 10,
                                      placed_at: Date.new(2016, 10, 15))
      order_out_of_range = Order.new(amount: 6,
                                     placed_at: Date.new(2016, 1, 1))
      orders = [order_within_range1, order_within_range2, order_out_of_range]

      date_range = DateRange.new(Date.new(2016, 10, 1), Date.new(2016, 10, 31))
      expect(OrdersReport.
             new(orders, date_range).
             total_sales_within_date_range).to eq(15)
    end
  end
end
```
ここでやっているのはそれまでstart_dateとend_dateで指定していた部分をdate_rangeを使うように変更しただけ。

次にコードの方も変更する。
【変更後】

```rb
class OrdersReport
  def initialize(orders, date_range)
    @orders = orders
    @date_range = date_range
  end

  def total_sales_within_date_range
    orders_within_range.map(&:amount).inject(0) do |sum, amount|
      sum + amount
    end
  end

  private

  def orders_within_range
    @orders.select do |order|
      order.placed_between?(@date_range)
    end
  end
end

class DateRange < Struct.new(:start_date, :end_date)
end

class Order < OpenStruct
  def placed_between?(date_range)
    placed_at >= date_range.start_date && placed_at <= date_range.end_date
  end
end
```

こうしてDateRangeを使ってひとまとめにすることですごくシンプルにコードが仕上がっている。StructでDataRangeを作るだけで、常にstart_dateとend_dataをペアで使うことが誰でも一目見ただけで容易に読み取れる。

それだけではない。この変更によって疎結合が達成されている。疎結合とは各コンポーネント間の結合が薄いということ。結合は薄ければ薄いほどいい。
例えばコンポーネントAとコンポーネントBが密接に結合されている状態は変更が容易でなくなる。Aを変更すればBも変更しなければならない、となってしまう。バグが派生するのは往々にして、ある箇所の変更が予想もしなかった別の箇所に影響を与えてしまったことが原因となっている。
もしAとBの間の結合が薄ければAを変更してもBの変更は要らない、となりオブジェクト指向設計で言うところの「容易に変更が可能で再利用もやりやすい」となる。これこそが理想の形。

結合度合いを測るひとつの目安が引数の数。引数の数は少なければ少ないほどいい。引数が多い場合はそれらの変更がたくさん影響を及ぼすことになるからだ。
今回の変更により引数が３つから２つに減らすことができた。

しかしまた新たな問題がある。
Orderクラスの中にplaced_between?があって、その日付の範囲を計算しているがこれはOrderの責任とは言えない。Orderの中に日付範囲を判断する機能がある、ってのは普通の感覚では気付き難い。
これはDateRangeの責任と言える。placed_between?の処理をDateRangeに入れた方が再利用性も高まる。

【変更前】

```rb
class Order < OpenStruct
  def placed_between?(date_range)
    placed_at >= date_range.start_date && placed_at <= date_range.end_date
  end
end
```

日付の範囲の処理をDateRangeに移動した後のコードがこれ。
【変更後】

```rb
class DateRange < Struct.new(:start_date, :end_date)
  def include?(date)
    date >= start_date && date <= end_date
  end
end

class Order < OpenStruct
  def placed_between?(date_range)
    date_range.include?(placed_at)
  end
end
```
これでOrderにとってはただそのdate_rangeにplaced_atが含まれているかどうかを問い合わせればいいだけになった。後はDateRangeがやってくれる。

日付の範囲を判断する処理は単純でdateの大小を２つ比較しているだけ。でもここはもう少しいいRubyの書き方がある。
【変更前】

```rb
  def include?(date)
    date >= start_date && date <= end_date
  end
```

ここはcover?を使うことでシンプルで読みやすい書き方ができる。
<a href="http://ruby-doc.org/core-2.2.0/Range.html#method-i-cover-3F">Ruby - cover? ドキュメント</a>
【変更後】

```rb
  def include?(date)
    (start_date..end_date).cover? date
  end
```
これは直感的で分かりやすい。Rubyサイコー。

ここまで変更した内容を反映した全体像
【変更後の全体像】

```rb
class OrdersReport
  def initialize(orders, date_range)
    @orders = orders
    @date_range = date_range
  end

  def total_sales_within_date_range
    orders_within_range.map(&:amount).inject(0) do |sum, amount|
      sum + amount
    end
  end

  private

  def orders_within_range
    @orders.select do |order|
      order.placed_between?(@date_range)
    end
  end
end

class DateRange < Struct.new(:start_date, :end_date)
  def include?(date)
    (start_date..end_date).cover? date
  end
end

class Order < OpenStruct
  def placed_between?(date_range)
    date_range.include?(placed_at)
  end
end
```

これでだいぶオブジェクト指向設計らしくなってきたので「いいね」ぐらいのレベルになったよう。でもまだまだ「スゲーいいね」にするための余地はある。

# ３.「いいね」から「スゲーいいね」にするためのリファクタリング

ここまでのコードの中にとても読みにくい箇所があって、それはtotal_sales_within_date_rangeの辺り。
【変更前】

```rb
  def total_sales_within_date_range
    orders_within_range.map(&:amount).inject(0) do |sum, amount|
      sum + amount
    end
  end
```
mapしてamountがあって、それをinjectして初期値は０で、、、ってややこしすぎ。

ここはパブリックメソッドであり、クラス外からも参照される箇所になる。そうした外からも参照される箇所は極力シンプルにするようにすべき。誰も複雑なモノを呼びたくない。パブリックメソッドをシンプルで究極に可読性を上げることで、再利用性が高まる。
その下のprivateメソッドは多少複雑でも構わない。
パブリックメソッドをどのぐらいシンプルにするべきか、は「読んだら一瞬で分かるぐらい」がベスト。具体的にはこんな感じ。

【変更後】

```rb
  def total_sales_within_date_range
    total_sales(orders_within_range)
  end
```
これでもう一目瞭然。total_sales（総売上）はorders_within_range（範囲内のオーダ）から計算する、と。変更前に比べて脳への負荷が1%ぐらいで済む。

この変更にともなってtotal_salesという名のprivateメソッドに処理を移行させる。

```rb
  private

  def total_sales(orders)
    orders.map(&:amount).inject(0) do |sum, amount|
      sum + amount
    end
  end
```

ここにまだ一工夫ができる。
injectのちょっとした用法で:+を使うことで１行で表現できる。慣れている人にとってはお馴染みの方法で可読性がさらに上がる。

【変更後】

```rb
  def total_sales(orders)
    orders.map(&:amount).inject(0, :+)
  end
```
なんとたったの１行で表現できる。:+の詳しい解説はこことか分かりやすい。
[ちょっとわかりにくいけど非常に便利なinjectメソッド](http://akisute3.hatenablog.com/entry/20111122/1322153061)
もう:+はそのまま覚えておいても損はない。

これでリファクタリングは終了。これまでの全てのリファクタリングを反映させた全体像がこれ。
【完成したコード】

```rb
class OrdersReport
  def initialize(orders, date_range)
    @orders = orders
    @date_range = date_range
  end

  def total_sales_within_date_range
    total_sales(orders_within_range)
  end

  private

  def total_sales(orders)
    orders.map(&:amount).inject(0, :+)
  end

  def orders_within_range
    @orders.select { |order| order.placed_between?(@date_range) }
  end
end

class DateRange < Struct.new(:start_date, :end_date)
  def include?(date)
    (start_date..end_date).cover? date
  end
end

class Order < OpenStruct
  def placed_between?(date_range)
    date_range.include?(placed_at)
  end
end
```
もう最初のコードと比べると可読性、単一責任、再利用性、疎結合、と全ての要素が満たされて格段に良くなっているのが分かる。ほとんどのメソッド内の行数が１行。（２行なのはinitializeのみ）気持ちいいぐらいに読みやすい。


【リファクタリング前のイケてないコード】

```rb
class OrdersReport
  def initialize(orders, start_date, end_date)
    @orders = orders
    @start_date = start_date
    @end_date = end_date
  end

  def total_sales_within_date_range
    orders_within_range = []
    @orders.each do |order|
      if order.placed_at >= @start_date && order.placed_at <= @end_date
        orders_within_range << order
      end
    end

    sum = 0
    orders_within_range.each do |order|
      sum += order.amount
    end
    sum

  end
end

class Order < OpenStruct
end
```

最初のイケてなかった頃の変更前と変更後とを比較した。

|      | 変更前 | 変更後 |
|:---|:-----|:-----|
|可読性|読めても時間かかる|スッキリ読める|
|責任 |１メソッドに複数責任|キレイに単一責任|
|再利用性|ほぼ無理|容易に再利用可能|
|結合|密結合|疎結合|

要素毎に再確認すると凄まじいぐらいに改善されていることが分かる。

今回の例にしたコード**だけ**を見ると「１回しか呼んでない引数にわざわざStructなんか定義して、それ必要か？」とか思われそうだが、それはこのコード例**だけ**を見ているからだ。これがある程度の規模のプロジェクトの一部だと仮定すると、より分かりやすくなる。その規模になれば必ず誰かがどこかで再利用する。その際に変更前と変更後のコードと、どちらがよりメンテナンスが容易で再利用がしやすいか？と考えれば明らかに変更後の方になる。

「期間内の総売上を出力するコードを書いてくれ」と頼まれて、そのままそれだけを書いてしまったのが変更前のコード。
「期間内の総売上の出力が必要でかつ、後で誰かがこのコードをメンテナンスして、また一部を再利用することがあるな」と想定して作られたのが変更後のコードになる。誰でも後者の方の考えを持つエンジニアと一緒に働きたいはず。

ということで「Rubyのリファクタリングでイケてないコードを美しいオブジェクト指向設計へ改良するための方法」でした。

実はここに書いている内容はほとんど「Practical Object-Oriented Design in Ruby」という本の受け売り。もしここに書いたようなオブジェクト指向設計やリファクタリングについて「もっと深く知りたい」とお考えであれば、本書を読めば、この記事の１００倍は納得感が得られると思う。イケてるコードを書きたい全てのエンジニアにとって「買っても絶対に損は無い本」と断言できるオススメの良書。詳しくは[こちらの記事](http://tango-ruby.hatenablog.com/entry/2015/05/27/234224)に書いた。
[英語とプログラミングを同時に勉強するなら「Practical Object-Oriented Design in Ruby」の一択](http://tango-ruby.hatenablog.com/entry/2015/05/27/234224)



# エンジニアの皆様へ
「[ほとんどのエンジニアには解けるが、下位10％のダメなエンジニアにだけ解けないパズル?](http://tango-ruby.hatenablog.com/entry/2015/11/30/122814)」なるものをシリーズ化して８パズル作成した。もしご興味あれば解いてみてください。
http://tango-ruby.hatenablog.com/entry/2015/11/30/122814