вопрос реализации Rspec теста рубин

Question

у меня есть этот тест в рубине я пытаюсь реализовать требует «silly_blocks»

describe "some silly block functions" do 

    describe "reverser" do 
    it "reverses the string returned by the default block" do 
     result = reverser do 
     "hello" 
     end 
     result.should == "olleh" 
    end 

    it "reverses each word in the string returned by the default block" do 
     result = reverser do 
     "hello dolly" 
     end 
     result.should == "olleh yllod" 
    end 
    end 

вот метод

def do_reverse(str) 
str = str.split 
first_str = str[0].reverse 
second_str= str[1] 
if (second_str == nil) 
    str = first_str.to_s 
else 
second_str = str[1].reverse 
str = (first_str +" "+ second_str) 
end 
end 

, что это лучший способ что я мог бы его реализовать. когда я пытаюсь опрокинуть тест, он провалился, но метод сам по себе возвращает резерв. Я немного смущен.

Answer 1

Вот простой способ сделать то, что вы ищете, со спецификациями.

# lib/reverse_words.rb 
def reverse_words(phrase) 
    return '' if phrase.nil? 
    words = phrase.split 
    phrase.split.map(&:reverse!).join(' ') 
end 

def reverser 
    reverse_words(yield) 
end 

# spec/reverse_words_spec.rb 
describe "#reverse_words" do 
    context "when single word" do 
    subject { reverse_words("hello") } 
    it { should == "olleh" } 
    end 

    context "when multiple words" do 
    subject { reverse_words("hello dolly") } 
    it { should == "olleh yllod" } 
    end 

    context "when nil" do 
    subject { reverse_words(nil) } 
    it { should == '' } 
    end 

    context "when empty" do 
    subject { reverse_words('') } 
    it { should == '' } 
    end 

end 

Обратите внимание, что reverser спецификации просто использует поведение, которое reverse_words уже specced пройти.

describe "#reverser" do 
    subject do 
    reverser do 
     "this is a test" 
    end 
    end 
    it { should == reverse_words("this is a test") } 
end 

Вот менее многословным reverse_words спецификации:

describe "#reverse_words (less wordy)" do 
    # counterintuitive keys as answers to support the nil case 
    cases = { "olleh" => "hello", 
     "olleh yllod" => "hello dolly", 
     ''   => nil, 
     ''   => '' 
    } 

    cases.each_pair do |expected, input| 
    context "#{input} should equal #{expected}" do 
     subject { reverse_words(input) } 
     it { should == expected } 
    end 
    end 
end 

Answer 2

Это работает. Данные, которые вы хотите, сохраняются в «yield».

def reverser 
    yield.gsub(/\w+/) { |w| w.each_char.to_a.reverse.join } 
end 

Answer 3

Попробуйте этот код:

def reverser 

    yield.split.map { |word| word.reverse}.join(" ") 

end 

Answer 4

Мой метод реверса:

def reverser 
    # yield is the string given in the block 
    words = yield.split(' ') 
    final = [] 
    words.each do |word| 
     final.push(word.reverse) 
    end 
    final.join(' ') 
end 

Answer 5

Зв Я пришел сюда и искал информацию о том, как это сделать. Поскольку язык не был ясен. Я пошел и посмотрел на место, и нашел достаточно информации, чтобы пройти тесты.

Таким образом, блоки являются те, что между фигурными скобками, которые иногда следуют функции рубина, такие как

list.each {|i| i.reverse} 

Так что спецификация делает пытается выяснить, что происходит, когда он делает:

rerverser {"hello"} 

положив выход в функции просто возвращает то, что в блоке, так

def print_block 
    puts yield 
end 

print_block {"Hello world."} 

#=> "Hello world" 

Тогда вы можете просто манипулировать доходностью, как если бы вы манипулировали любым аргументом. В блоках гораздо больше. Here's a good place to start, но это все, что вам нужно знать, чтобы решить упражнение, если до сих пор вы решили все упражнения Learn_ruby Test First.