yard 0.9.18 → 0.9.19

data/lib/yard/handlers/ruby/legacy/class_condition_handler.rb

@@ -1,83 +1,83 @@
-# frozen_string_literal: true
-# (see Ruby::ClassConditionHandler)
-# @since 0.5.4
-class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < YARD::Handlers::Ruby::Legacy::Base
-  namespace_only
-  handles TkIF, TkELSIF, TkUNLESS
-
-  process do
-    condition = parse_condition
-    if condition.nil?
-      # Parse both blocks if we're unsure of the condition
-      parse_then_block
-      parse_else_block
-    elsif condition
-      parse_then_block
-    else
-      parse_else_block
-    end
-  end
-
-  protected
-
-  # Parses the condition part of the if/unless statement
-  #
-  # @return [true, false, nil] true if the condition can be definitely
-  #   parsed to true, false if not, and nil if the condition cannot be
-  #   parsed with certainty (it's dynamic)
-  # @since 0.5.5
-  def parse_condition
-    condition = nil
-
-    # Right now we can handle very simple unary conditions like:
-    #   if true
-    #   if false
-    #   if 0
-    #   if 100 (not 0)
-    #   if defined? SOME_CONSTANT
-    #
-    # The last case will do a lookup in the registry and then one
-    # in the Ruby world (using eval).
-    case statement.tokens[1..-1].to_s.strip
-    when /^(\d+)$/
-      condition = $1 != "0"
-    when /^defined\?\s*\(?\s*([A-Za-z0-9:_]+?)\s*\)?$/
-      # defined? keyword used, let's see if we can look up the name
-      # in the registry, then we'll try using Ruby's powers. eval() is not
-      # *too* dangerous here since code is not actually executed.
-      name = $1
-      obj = YARD::Registry.resolve(namespace, name, true)
-      begin
-        condition = true if obj || Object.instance_eval("defined? #{name}")
-      rescue SyntaxError, NameError
-        condition = false
-      end
-    when "true"
-      condition = true
-    when "false"
-      condition = false
-    end
-
-    if TkUNLESS === statement.tokens.first
-      condition = !condition unless condition.nil?
-    end
-    condition
-  end
-
-  # @since 0.5.5
-  def parse_then_block
-    parse_block(:visibility => visibility)
-  end
-
-  # @since 0.5.5
-  def parse_else_block
-    return unless statement.block
-    stmtlist = YARD::Parser::Ruby::Legacy::StatementList
-    stmtlist.new(statement.block).each do |stmt|
-      next unless TkELSE === stmt.tokens.first
-      push_state(:visibility => visibility) do
-        parser.process(stmtlist.new(stmt.block))
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+# (see Ruby::ClassConditionHandler)
+# @since 0.5.4
+class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < YARD::Handlers::Ruby::Legacy::Base
+  namespace_only
+  handles TkIF, TkELSIF, TkUNLESS
+
+  process do
+    condition = parse_condition
+    if condition.nil?
+      # Parse both blocks if we're unsure of the condition
+      parse_then_block
+      parse_else_block
+    elsif condition
+      parse_then_block
+    else
+      parse_else_block
+    end
+  end
+
+  protected
+
+  # Parses the condition part of the if/unless statement
+  #
+  # @return [true, false, nil] true if the condition can be definitely
+  #   parsed to true, false if not, and nil if the condition cannot be
+  #   parsed with certainty (it's dynamic)
+  # @since 0.5.5
+  def parse_condition
+    condition = nil
+
+    # Right now we can handle very simple unary conditions like:
+    #   if true
+    #   if false
+    #   if 0
+    #   if 100 (not 0)
+    #   if defined? SOME_CONSTANT
+    #
+    # The last case will do a lookup in the registry and then one
+    # in the Ruby world (using eval).
+    case statement.tokens[1..-1].to_s.strip
+    when /^(\d+)$/
+      condition = $1 != "0"
+    when /^defined\?\s*\(?\s*([A-Za-z0-9:_]+?)\s*\)?$/
+      # defined? keyword used, let's see if we can look up the name
+      # in the registry, then we'll try using Ruby's powers. eval() is not
+      # *too* dangerous here since code is not actually executed.
+      name = $1
+      obj = YARD::Registry.resolve(namespace, name, true)
+      begin
+        condition = true if obj || Object.instance_eval("defined? #{name}")
+      rescue SyntaxError, NameError
+        condition = false
+      end
+    when "true"
+      condition = true
+    when "false"
+      condition = false
+    end
+
+    if TkUNLESS === statement.tokens.first
+      condition = !condition unless condition.nil?
+    end
+    condition
+  end
+
+  # @since 0.5.5
+  def parse_then_block
+    parse_block(:visibility => visibility)
+  end
+
+  # @since 0.5.5
+  def parse_else_block
+    return unless statement.block
+    stmtlist = YARD::Parser::Ruby::Legacy::StatementList
+    stmtlist.new(statement.block).each do |stmt|
+      next unless TkELSE === stmt.tokens.first
+      push_state(:visibility => visibility) do
+        parser.process(stmtlist.new(stmt.block))
+      end
+    end
+  end
+end

data/lib/yard/handlers/ruby/legacy/class_handler.rb

@@ -1,113 +1,113 @@
-# frozen_string_literal: true
-# (see Ruby::ClassHandler)
-class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy::Base
-  include YARD::Handlers::Ruby::StructHandlerMethods
-  handles TkCLASS
-  namespace_only
-
-  process do
-    if statement.tokens.to_s =~ /^class\s+(#{NAMESPACEMATCH})\s*(?:<\s*(.+)|\Z)/m
-      classname = $1
-      superclass_def = $2
-      superclass = parse_superclass($2)
-      classname = classname.gsub(/\s/, '')
-      if superclass == "Struct"
-        is_a_struct = true
-        superclass = struct_superclass_name(superclass_def)
-        create_struct_superclass(superclass, superclass_def)
-      end
-      undocsuper = superclass_def && superclass.nil?
-
-      klass = register ClassObject.new(namespace, classname) do |o|
-        o.superclass = superclass if superclass
-        o.superclass.type = :class if o.superclass.is_a?(Proxy)
-      end
-      if is_a_struct
-        parse_struct_subclass(klass, superclass_def)
-      elsif klass
-        create_attributes(klass, members_from_tags(klass))
-      end
-      parse_block(:namespace => klass)
-
-      if undocsuper
-        raise YARD::Parser::UndocumentableError, 'superclass (class was added without superclass)'
-      end
-    elsif statement.tokens.to_s =~ /^class\s*<<\s*([\w\:\s]+)/
-      classname = $1.gsub(/\s/, '')
-      proxy = Proxy.new(namespace, classname)
-
-      # Allow constants to reference class names
-      if ConstantObject === proxy
-        if proxy.value =~ /\A#{NAMESPACEMATCH}\Z/
-          proxy = Proxy.new(namespace, proxy.value)
-        else
-          raise YARD::Parser::UndocumentableError, "constant class reference '#{classname}'"
-        end
-      end
-
-      if classname == "self"
-        parse_block(:namespace => namespace, :scope => :class)
-      elsif classname[0, 1] =~ /[A-Z]/
-        register ClassObject.new(namespace, classname) if Proxy === proxy
-        parse_block(:namespace => proxy, :scope => :class)
-      else
-        raise YARD::Parser::UndocumentableError, "class '#{classname}'"
-      end
-    else
-      raise YARD::Parser::UndocumentableError, "class: #{statement.tokens}"
-    end
-  end
-
-  private
-
-  # Extracts the parameter list from the Struct.new declaration and returns it
-  # formatted as a list of member names. Expects the user will have used symbols
-  # to define the struct member names
-  #
-  # @param [String] superstring the string declaring the superclass
-  # @return [Array<String>] a list of member names
-  def extract_parameters(superstring)
-    paramstring = superstring.match(/\A(O?Struct)\.new\((.*?)\)/)[2]
-    paramstring.split(",").select {|x| x.strip[0, 1] == ":" }.map {|x| x.strip[1..-1] } # the 1..-1 chops the leading :
-  end
-
-  def create_struct_superclass(superclass, superclass_def)
-    return if superclass == "Struct"
-    the_super = register ClassObject.new(P("Struct"), superclass[8..-1]) do |o|
-      o.superclass = "Struct"
-    end
-    parse_struct_subclass(the_super, superclass_def)
-    the_super
-  end
-
-  def struct_superclass_name(superclass)
-    match = superclass.match(/\A(Struct)\.new\((.*?)\)/)
-    if match
-      paramstring = match[2].split(",")
-      first = paramstring.first.strip
-      if first[0, 1] =~ /['"]/ && first[-1, 1] =~ /['"]/ && first !~ /\#\{/
-        return "Struct::#{first[1..-2]}"
-      end
-    end
-    "Struct"
-  end
-
-  def parse_struct_subclass(klass, superclass_def)
-    # Bounce if there's no parens
-    return unless superclass_def =~ /O?Struct\.new\((.*?)\)/
-    members = extract_parameters(superclass_def)
-    create_attributes(klass, members)
-  end
-
-  def parse_superclass(superclass)
-    case superclass
-    when /\A(#{NAMESPACEMATCH})(?:\s|\Z)/,
-         /\A(Struct|OStruct)\.new/,
-         /\ADelegateClass\((.+?)\)\s*\Z/,
-         /\A(#{NAMESPACEMATCH})\(/
-      $1
-    when "self"
-      namespace.path
-    end
-  end
-end
+# frozen_string_literal: true
+# (see Ruby::ClassHandler)
+class YARD::Handlers::Ruby::Legacy::ClassHandler < YARD::Handlers::Ruby::Legacy::Base
+  include YARD::Handlers::Ruby::StructHandlerMethods
+  handles TkCLASS
+  namespace_only
+
+  process do
+    if statement.tokens.to_s =~ /^class\s+(#{NAMESPACEMATCH})\s*(?:<\s*(.+)|\Z)/m
+      classname = $1
+      superclass_def = $2
+      superclass = parse_superclass($2)
+      classname = classname.gsub(/\s/, '')
+      if superclass == "Struct"
+        is_a_struct = true
+        superclass = struct_superclass_name(superclass_def)
+        create_struct_superclass(superclass, superclass_def)
+      end
+      undocsuper = superclass_def && superclass.nil?
+
+      klass = register ClassObject.new(namespace, classname) do |o|
+        o.superclass = superclass if superclass
+        o.superclass.type = :class if o.superclass.is_a?(Proxy)
+      end
+      if is_a_struct
+        parse_struct_subclass(klass, superclass_def)
+      elsif klass
+        create_attributes(klass, members_from_tags(klass))
+      end
+      parse_block(:namespace => klass)
+
+      if undocsuper
+        raise YARD::Parser::UndocumentableError, 'superclass (class was added without superclass)'
+      end
+    elsif statement.tokens.to_s =~ /^class\s*<<\s*([\w\:\s]+)/
+      classname = $1.gsub(/\s/, '')
+      proxy = Proxy.new(namespace, classname)
+
+      # Allow constants to reference class names
+      if ConstantObject === proxy
+        if proxy.value =~ /\A#{NAMESPACEMATCH}\Z/
+          proxy = Proxy.new(namespace, proxy.value)
+        else
+          raise YARD::Parser::UndocumentableError, "constant class reference '#{classname}'"
+        end
+      end
+
+      if classname == "self"
+        parse_block(:namespace => namespace, :scope => :class)
+      elsif classname[0, 1] =~ /[A-Z]/
+        register ClassObject.new(namespace, classname) if Proxy === proxy
+        parse_block(:namespace => proxy, :scope => :class)
+      else
+        raise YARD::Parser::UndocumentableError, "class '#{classname}'"
+      end
+    else
+      raise YARD::Parser::UndocumentableError, "class: #{statement.tokens}"
+    end
+  end
+
+  private
+
+  # Extracts the parameter list from the Struct.new declaration and returns it
+  # formatted as a list of member names. Expects the user will have used symbols
+  # to define the struct member names
+  #
+  # @param [String] superstring the string declaring the superclass
+  # @return [Array<String>] a list of member names
+  def extract_parameters(superstring)
+    paramstring = superstring.match(/\A(O?Struct)\.new\((.*?)\)/)[2]
+    paramstring.split(",").select {|x| x.strip[0, 1] == ":" }.map {|x| x.strip[1..-1] } # the 1..-1 chops the leading :
+  end
+
+  def create_struct_superclass(superclass, superclass_def)
+    return if superclass == "Struct"
+    the_super = register ClassObject.new(P("Struct"), superclass[8..-1]) do |o|
+      o.superclass = "Struct"
+    end
+    parse_struct_subclass(the_super, superclass_def)
+    the_super
+  end
+
+  def struct_superclass_name(superclass)
+    match = superclass.match(/\A(Struct)\.new\((.*?)\)/)
+    if match
+      paramstring = match[2].split(",")
+      first = paramstring.first.strip
+      if first[0, 1] =~ /['"]/ && first[-1, 1] =~ /['"]/ && first !~ /\#\{/
+        return "Struct::#{first[1..-2]}"
+      end
+    end
+    "Struct"
+  end
+
+  def parse_struct_subclass(klass, superclass_def)
+    # Bounce if there's no parens
+    return unless superclass_def =~ /O?Struct\.new\((.*?)\)/
+    members = extract_parameters(superclass_def)
+    create_attributes(klass, members)
+  end
+
+  def parse_superclass(superclass)
+    case superclass
+    when /\A(#{NAMESPACEMATCH})(?:\s|\Z)/,
+         /\A(Struct|OStruct)\.new/,
+         /\ADelegateClass\((.+?)\)\s*\Z/,
+         /\A(#{NAMESPACEMATCH})\(/
+      $1
+    when "self"
+      namespace.path
+    end
+  end
+end

data/lib/yard/handlers/ruby/legacy/class_variable_handler.rb

@@ -1,15 +1,15 @@
-# frozen_string_literal: true
-# (see Ruby::ClassVariableHandler)
-class YARD::Handlers::Ruby::Legacy::ClassVariableHandler < YARD::Handlers::Ruby::Legacy::Base
-  HANDLER_MATCH = /\A@@\w+\s*=\s*/m
-  handles HANDLER_MATCH
-  namespace_only
-
-  process do
-    name, value = *statement.tokens.to_s.split(/\s*=\s*/, 2)
-    register ClassVariableObject.new(namespace, name) do |o|
-      o.source = statement
-      o.value = value.strip
-    end
-  end
-end
+# frozen_string_literal: true
+# (see Ruby::ClassVariableHandler)
+class YARD::Handlers::Ruby::Legacy::ClassVariableHandler < YARD::Handlers::Ruby::Legacy::Base
+  HANDLER_MATCH = /\A@@\w+\s*=\s*/m
+  handles HANDLER_MATCH
+  namespace_only
+
+  process do
+    name, value = *statement.tokens.to_s.split(/\s*=\s*/, 2)
+    register ClassVariableObject.new(namespace, name) do |o|
+      o.source = statement
+      o.value = value.strip
+    end
+  end
+end

data/lib/yard/handlers/ruby/legacy/comment_handler.rb

@@ -1,10 +1,10 @@
-# frozen_string_literal: true
-# (see Ruby::CommentHandler)
-class YARD::Handlers::Ruby::Legacy::CommentHandler < YARD::Handlers::Ruby::Legacy::Base
-  handles TkCOMMENT
-  namespace_only
-
-  process do
-    register_docstring(nil)
-  end
-end
+# frozen_string_literal: true
+# (see Ruby::CommentHandler)
+class YARD::Handlers::Ruby::Legacy::CommentHandler < YARD::Handlers::Ruby::Legacy::Base
+  handles TkCOMMENT
+  namespace_only
+
+  process do
+    register_docstring(nil)
+  end
+end

data/lib/yard/handlers/ruby/legacy/constant_handler.rb

@@ -1,29 +1,29 @@
-# frozen_string_literal: true
-# (see Ruby::ConstantHandler)
-class YARD::Handlers::Ruby::Legacy::ConstantHandler < YARD::Handlers::Ruby::Legacy::Base
-  include YARD::Handlers::Ruby::StructHandlerMethods
-  HANDLER_MATCH = /\A[A-Z]\w*\s*=[^=]\s*/m
-  handles HANDLER_MATCH
-  namespace_only
-
-  process do
-    name, value = *statement.tokens.to_s.split(/\s*=\s*/, 2)
-    if value =~ /\A\s*Struct.new(?:\s*\(?|\b)/
-      process_structclass(name, $')
-    else
-      register ConstantObject.new(namespace, name) {|o| o.source = statement; o.value = value.strip }
-    end
-  end
-
-  private
-
-  def process_structclass(classname, parameters)
-    klass = create_class(classname, P(:Struct))
-    create_attributes(klass, extract_parameters(parameters))
-  end
-
-  def extract_parameters(parameters)
-    members = tokval_list(YARD::Parser::Ruby::Legacy::TokenList.new(parameters), TkSYMBOL)
-    members.map(&:to_s)
-  end
-end
+# frozen_string_literal: true
+# (see Ruby::ConstantHandler)
+class YARD::Handlers::Ruby::Legacy::ConstantHandler < YARD::Handlers::Ruby::Legacy::Base
+  include YARD::Handlers::Ruby::StructHandlerMethods
+  HANDLER_MATCH = /\A[A-Z]\w*\s*=[^=]\s*/m
+  handles HANDLER_MATCH
+  namespace_only
+
+  process do
+    name, value = *statement.tokens.to_s.split(/\s*=\s*/, 2)
+    if value =~ /\A\s*Struct.new(?:\s*\(?|\b)/
+      process_structclass(name, $')
+    else
+      register ConstantObject.new(namespace, name) {|o| o.source = statement; o.value = value.strip }
+    end
+  end
+
+  private
+
+  def process_structclass(classname, parameters)
+    klass = create_class(classname, P(:Struct))
+    create_attributes(klass, extract_parameters(parameters))
+  end
+
+  def extract_parameters(parameters)
+    members = tokval_list(YARD::Parser::Ruby::Legacy::TokenList.new(parameters), TkSYMBOL)
+    members.map(&:to_s)
+  end
+end