setup.rb in yard-0.9.6

- old
+ new

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 include Helpers::ModuleHelper
 
 def init
   sections :header, :box_info, :pre_docstring, T('docstring'), :children,
     :constant_summary, [T('docstring')], :inherited_constants,
@@ -26,19 +27,19 @@
   erb(:children)
 end
 
 def methodmissing
   mms = object.meths(:inherited => true, :included => true)
-  return unless @mm = mms.find {|o| o.name == :method_missing && o.scope == :instance }
-  erb(:methodmissing)
+  @mm = mms.find {|o| o.name == :method_missing && o.scope == :instance }
+  erb(:methodmissing) if @mm
 end
 
 def method_listing(include_specials = true)
   return @smeths ||= method_listing.reject {|o| special_method?(o) } unless include_specials
-  return @meths if @meths
+  return @meths if defined?(@meths) && @meths
   @meths = object.meths(:inherited => false, :included => !options.embed_mixins.empty?)
-  if options.embed_mixins.size > 0
+  unless options.embed_mixins.empty?
     @meths = @meths.reject {|m| options.embed_mixins_match?(m.namespace) == false }
   end
   @meths = sort_listing(prune_method_listing(@meths))
   @meths
 end
@@ -48,83 +49,80 @@
   return true if meth.constructor?
   false
 end
 
 def attr_listing
-  return @attrs if @attrs
+  return @attrs if defined?(@attrs) && @attrs
   @attrs = []
   object.inheritance_tree(true).each do |superclass|
     next if superclass.is_a?(CodeObjects::Proxy)
-    next if options.embed_mixins.size > 0 &&
-      !options.embed_mixins_match?(superclass)
+    next if !options.embed_mixins.empty? &&
+            !options.embed_mixins_match?(superclass)
     [:class, :instance].each do |scope|
-      superclass.attributes[scope].each do |name, rw|
+      superclass.attributes[scope].each do |_name, rw|
         attr = prune_method_listing([rw[:read], rw[:write]].compact, false).first
         @attrs << attr if attr
       end
     end
     break if options.embed_mixins.empty?
   end
   @attrs = sort_listing(@attrs)
 end
 
 def constant_listing
-  return @constants if @constants
+  return @constants if defined?(@constants) && @constants
   @constants = object.constants(:included => false, :inherited => false)
   @constants += object.cvars
   @constants = run_verifier(@constants)
   @constants
 end
 
 def sort_listing(list)
   list.sort_by {|o| [o.scope.to_s, o.name.to_s.downcase] }
 end
 
-def inherited_attr_list(&block)
+def inherited_attr_list
   object.inheritance_tree(true)[1..-1].each do |superclass|
     next if superclass.is_a?(YARD::CodeObjects::Proxy)
-    next if options.embed_mixins.size > 0 && options.embed_mixins_match?(superclass) != false
+    next if !options.embed_mixins.empty? && options.embed_mixins_match?(superclass) != false
     attribs = superclass.attributes[:instance]
-    attribs = attribs.reject {|name, rw| object.child(:scope => :instance, :name => name) != nil }
-    attribs = attribs.sort_by {|args| args.first.to_s }.map {|n, m| m[:read] || m[:write] }
+    attribs = attribs.select {|name, _rw| object.child(:scope => :instance, :name => name).nil? }
+    attribs = attribs.sort_by {|args| args.first.to_s }.map {|_n, m| m[:read] || m[:write] }
     attribs = prune_method_listing(attribs, false)
-    yield superclass, attribs if attribs.size > 0
+    yield superclass, attribs unless attribs.empty?
   end
 end
 
-def inherited_constant_list(&block)
+def inherited_constant_list
   object.inheritance_tree(true)[1..-1].each do |superclass|
     next if superclass.is_a?(YARD::CodeObjects::Proxy)
-    next if options.embed_mixins.size > 0 && options.embed_mixins_match?(superclass) != false
+    next if !options.embed_mixins.empty? && options.embed_mixins_match?(superclass) != false
     consts = superclass.constants(:included => false, :inherited => false)
-    consts = consts.reject {|const| object.child(:type => :constant, :name => const.name) != nil }
+    consts = consts.select {|const| object.child(:type => :constant, :name => const.name).nil? }
     consts = consts.sort_by {|const| const.name.to_s }
     consts = run_verifier(consts)
-    yield superclass, consts if consts.size > 0
+    yield superclass, consts unless consts.empty?
   end
 end
 
 def docstring_full(obj)
-  docstring = ""
-  if obj.tags(:overload).size == 1 && obj.docstring.empty?
-    docstring = obj.tag(:overload).docstring
-  else
-    docstring = obj.docstring
-  end
+  docstring = obj.tags(:overload).size == 1 && obj.docstring.empty? ?
+    obj.tag(:overload).docstring : obj.docstring
 
   if docstring.summary.empty? && obj.tags(:return).size == 1 && obj.tag(:return).text
-    docstring = Docstring.new(obj.tag(:return).text.gsub(/\A([a-z])/) {|x| x.upcase }.strip)
+    docstring = Docstring.new(obj.tag(:return).text.gsub(/\A([a-z])/, &:upcase).strip)
   end
 
   docstring
 end
 
 def docstring_summary(obj)
   docstring_full(obj).summary
 end
 
 def groups(list, type = "Method")
-  if groups_data = object.groups
+  groups_data = object.groups
+  if groups_data
     list.each {|m| groups_data |= [m.group] if m.group && owner != m.namespace }
     others = list.select {|m| !m.group || !groups_data.include?(m.group) }
     groups_data.each do |name|
       items = list.select {|m| m.group == name }
       yield(items, name) unless items.empty?