重构RubyonRails模型

给定以下代码

您将如何重构它以使方法search\u word能够访问issueid

我想说，更改函数search_word以使其接受3个参数或将issueid设置为实例变量（@issueid）可能被视为坏做法的一个例子，但老实说，我找不到任何其他解决方案。如果除此之外没有其他解决方案，您介意解释一下没有其他解决方案的原因吗

请记住，它是一个RubyonRails模型

def search_type_of_relation_in_text(issueid, type_of_causality)
    relation_ocurrences = Array.new
    keywords_list = { 
        :C => ['cause', 'causes'],
        :I => ['prevent', 'inhibitors'],
        :P => ['type','supersets'],
        :E => ['effect', 'effects'],
        :R => ['reduce', 'inhibited'],
        :S => ['example', 'subsets'] 
    }[type_of_causality.to_sym]  

    for keyword in keywords_list
        relation_ocurrences + search_word(keyword, relation_type)
    end        

    return relation_ocurrences
end


def search_word(keyword, relation_type)
relation_ocurrences = Array.new

@buffer.search('//p[text()*= "'+keyword+'"]/a').each { |relation|

    relation_suggestion_url   = 'http://en.wikipedia.org'+relation.attributes['href']
    relation_suggestion_title = URI.unescape(relation.attributes['href'].gsub("_" , " ").gsub(/[\w\W]*\/wiki\//, ""))

    if not @current_suggested[relation_type].include?(relation_suggestion_url)
        if @accepted[relation_type].include?(relation_suggestion_url)
            relation_ocurrences << {:title => relation_suggestion_title, :wiki_url => relation_suggestion_url, :causality => type_of_causality, :status => "A", :issue_id => issueid}
        else
            relation_ocurrences << {:title => relation_suggestion_title, :wiki_url => relation_suggestion_url, :causality => type_of_causality, :status => "N", :issue_id => issueid}
        end

    end
} 

end

def search_type_of_relationship_in_text（issueid，type of_因果关系）
关系_ocurrences=Array.new
关键词列表={
：C=>[“原因”，“原因”]，
：I=>[“预防”，“抑制剂”]，
：P=>['type'，'superset']，
：E=>[“效果”，“效果”]，
：R=>[“减少”，“抑制”]，
：S=>[“示例”，“子集”]
}[因果关系类型到符号]
对于关键字列表中的关键字
关系词+搜索词（关键字，关系类型）
结束
返回关系
结束
定义搜索词（关键字、关系类型）
关系_ocurrences=Array.new
@buffer.search（'//p[text（）*=“'+关键字+“]/a”）。每个{124;关系|
关系(建议)http://en.wikipedia.org'+关系.属性['href']
relation\u suggestion\u title=URI.unescape（relation.attributes['href'].gsub（“\u”，”）.gsub（/[\w\w]*\/wiki\/，”）
如果不是@current\u Suggestive[关系类型]。包括？（关系建议url）
如果@accepted[关系类型]。包括？（关系建议url）
关系关系建议标题：维基建议url=>关系建议url：：因果关系=>因果关系类型：：状态=>“A”，：问题id=>问题id}
其他的
关系关系建议标题：维基建议url=>关系建议url：因果关系=>因果关系类型：：状态=>“N”，“问题id=>问题id}
结束
结束
} 
结束

如果需要其他上下文，请将其作为附加参数传递。这就是它的工作原理

将

@

-类型实例变量设置为传递上下文是错误的，正如您所识别的那样

有许多Ruby约定您似乎不知道：

• 不要使用

  数组。新建

  只需使用

  []

  ，而不要使用

  散列。新建

  使用

  {}

• 使用

  case

  语句或常量，而不是定义散列，然后仅检索其中一个元素，丢弃其余元素
• 除非严格必要，否则避免使用

  return

  ，因为默认情况下始终返回最后一个操作
• 对数组中的项目使用

  array.each do | item |

  而不是

• 使用

  do。。。对于多行块，结束

  而不是{…}，其中大括号版本通常为一行保留。避免与哈希声明混淆
• 当差异很小时，尽量避免重复大块代码。例如，声明一个临时变量，有条件地操作它，然后存储它，而不是定义多个独立变量

考虑到这一点，这里对其进行了修改：

KEYWORDS = { 
    :C => ['cause', 'causes'],
    :I => ['prevent', 'inhibitors'],
    :P => ['type','supersets'],
    :E => ['effect', 'effects'],
    :R => ['reduce', 'inhibited'],
    :S => ['example', 'subsets'] 
}

def search_type_of_relation_in_text(issue_id, type_of_causality)
  KEYWORDS[type_of_causality.to_sym].collect do |keyword|
    search_word(keyword, relation_type, issue_id)
  end
end

def search_word(keyword, relation_type, issue_id)
  relation_occurrences = [ ]

  @buffer.search(%Q{//p[text()*= "#{keyword}'"]/a}).each do |relation|
    relation_suggestion_url = "http://en.wikipedia.org#{relation.attributes['href']}"
    relation_suggestion_title = URI.unescape(relation.attributes['href'].gsub("_" , " ").gsub(/[\w\W]*\/wiki\//, ""))

    if (!@current_suggested[relation_type].include?(relation_suggestion_url))
      occurrence = {
        :title => relation_suggestion_title,
        :wiki_url => relation_suggestion_url,
        :causality => type_of_causality,
        :issue_id => issue_id
      }

      occurrence[:status] =
        if (@accepted[relation_type].include?(relation_suggestion_url))
          'A'
        else
          'N'
        end

      relation_ocurrences << occurrence
    end
  end 

  relation_occurrences
end

关键字={
：C=>[“原因”，“原因”]，
：I=>[“预防”，“抑制剂”]，
：P=>['type'，'superset']，
：E=>[“效果”，“效果”]，
：R=>[“减少”，“抑制”]，
：S=>[“示例”，“子集”]
}
文本中定义搜索关系类型（问题id、因果关系类型）
关键词[因果关系类型.到符号].收集do关键词|
搜索词（关键字、关系类型、问题id）
结束
结束
def搜索词（关键字、关系类型、问题id）
关系_事件=[]
@buffer.search（%Q{//p[text（）*=“#{keyword}'”/a}）。每个do |关系|
关系\建议\ url=”http://en.wikipedia.org#{relation.attributes['href']}”
relation\u suggestion\u title=URI.unescape（relation.attributes['href'].gsub（“\u”，”）.gsub（/[\w\w]*\/wiki\/，”）
if（！@current\u suggestive[关系类型]。包括？（关系建议url））
发生率={
：title=>关系\建议\标题，
：wiki\u url=>关系\u建议\u url，
：因果关系=>因果关系的类型，
：问题id=>问题id
}
事件[：状态]=
if（@accepted[relation\u type]。include？（relation\u suggestion\u url））
“A”
其他的
“不”
结束
关系\u ocurrences如果需要额外的上下文，请将其作为额外的参数传递。这就是它的工作原理

将
@
-类型实例变量设置为传递上下文是错误的，正如您所识别的那样

有许多Ruby约定您似乎不知道：


不要使用
数组。新建
只需使用
[]
，而不要使用
散列。新建
使用
{}
使用
case
语句或常量，而不是定义散列，然后仅检索其中一个元素，丢弃其余元素
除非严格必要，否则避免使用
return
，因为默认情况下始终返回最后一个操作
对数组中的项目使用
array.each do | item |
而不是

使用
do。。。对于多行块，结束
而不是

{…}，其中大括号版本通常为一行保留。避免与哈希声明混淆

当差异很小时，尽量避免重复大块代码。例如，声明一个临时变量，有条件地操作它，然后存储它，而不是定义多个独立变量

考虑到这一点，这里对其进行了修改：

KEYWORDS = { 
    :C => ['cause', 'causes'],
    :I => ['prevent', 'inhibitors'],
    :P => ['type','supersets'],
    :E => ['effect', 'effects'],
    :R => ['reduce', 'inhibited'],
    :S => ['example', 'subsets'] 
}

def search_type_of_relation_in_text(issue_id, type_of_causality)
  KEYWORDS[type_of_causality.to_sym].collect do |keyword|
    search_word(keyword, relation_type, issue_id)
  end
end

def search_word(keyword, relation_type, issue_id)
  relation_occurrences = [ ]

  @buffer.search(%Q{//p[text()*= "#{keyword}'"]/a}).each do |relation|
    relation_suggestion_url = "http://en.wikipedia.org#{relation.attributes['href']}"
    relation_suggestion_title = URI.unescape(relation.attributes['href'].gsub("_" , " ").gsub(/[\w\W]*\/wiki\//, ""))

    if (!@current_suggested[relation_type].include?(relation_suggestion_url))
      occurrence = {
        :title => relation_suggestion_title,
        :wiki_url => relation_suggestion_url,
        :causality => type_of_causality,
        :issue_id => issue_id
      }

      occurrence[:status] =
        if (@accepted[relation_type].include?(relation_suggestion_url))
          'A'
        else
          'N'
        end

      relation_ocurrences << occurrence
    end
  end 

  relation_occurrences
end

关键字={
：C=>[“原因”，“原因”]，
：I=>[“预防”，“抑制剂”]，
：P=>['type'，'superset']，
：E=>[“效果”，“效果”]，
：R=>[“减少”，“抑制”]，
：S=>[“示例”，“子集”]
}
文本中关系的定义搜索类型（问题一）