ruby​​作業單列表中的單個依賴關係正在複製其結果

Question

我有一個作業列表，並且寫了一個規範給以下問題，列表中的一個項目依賴於另一個項目。我得到的結果是兩次返回列表項c。現在的問題是：

Given the following job structure: 

a => 
b => c 
c => 
The result should be a sequence that positions c before b, containing all three jobs abc. 

我很困惑，因爲我的測試失敗瞭如下

1) JobsList should return ordered multiple jobs with the dependency if multiple jobs with single dependency were supplied 
    Failure/Error: expect(JobsList.sequence({'a' => nil, 'b' => 'c', 'c' => nil})).to eq ['a', 'c', 'b'] 

     expected: ["a", "c", "b"] 
      got: ["a", "c", "c", "b"] 

     (compared using ==) 

我在這裏無所適從我做錯了任何人都可以提出任何建議？

jobs_list_spec

require 'jobs_list' 

describe JobsList do 

    it "should return an empty sequence of jobs if a blank hash was supplied" do 
     expect(JobsList.sequence({})).to eq []  
    end 


    it "should return an single job character if a single jobs was supplied" do 
     expect(JobsList.sequence({'a' => nil})).to eq ['a']  
    end 

    it "should return multiple jobs characters if a multiple jobs were supplied" do 
     expect(JobsList.sequence({'a' => nil, 'b' => nil, 'c' => nil})).to eq ['a', 'b', 'c']  
    end 

    it "should return ordered multiple jobs with the dependency if multiple jobs with single dependency were supplied" do 
     expect(JobsList.sequence({'a' => nil, 'b' => 'c', 'c' => nil})).to eq ['a', 'c', 'b']  
    end 

jobs_list.rb

class JobsList 
    def self.sequence(jobs={}) 
     grouped_jobs = jobs.group_by{|k, v| v} 
     grouped_jobs.map do |k,v| 
      array = [] 
      if k 
       array = array + [k] 
      end 
      array = array + v.map{|a| a[0]} 
     end.flatten 
    end 
end 

Answer 1

我不確定是否有你的問題，但你可以試試這段代碼。

class JobsList 
    def self.sequence(jobs={}) 
    jobs.to_a.flatten.uniq.compact 
    end 
end 

Answer 2

一些指針，可以幫助：

1. 嘗試修改類的接口或移動邏輯到CL的實例屁股，而不是在班級方法，因爲它會使它很難與國家合作。
2. 其次嘗試將功能拆分爲具有表達性名稱的小類，它將幫助您更輕鬆地考慮邏輯。

如果你想保持目前的基於類的接口，想想下面的組織你的類方法：

def self.sequence(jobs) 
    JobList.new(jobs).sequence 
end 

現在，您可以將您的邏輯進入實例的方法;並不是說在類方法之間不能共享實例。但是這種方法可能更容易理解。

如果你完全陷入困境，看看我解決了Ordered Job Kata這個邏輯如何分解。

Answer 3

def self.sequence(jobs={}) 
    puts 'hi' 
    grouped_jobs = jobs.group_by{|k, v| v} 
    grouped_jobs.map do |k,v| 
     array = [] 
     if k 
      array = array + [k] 
     end 
     array = array + v.map{|a| a[0]} 
    end.flatten.uniq.compact 
end