yard 0.9.18 → 0.9.19

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

@@ -1,92 +1,92 @@
-# frozen_string_literal: true
-# Matches if/unless conditions inside classes and attempts to process only
-# one branch (by evaluating the condition if possible).
-#
-# @example A simple class conditional
-#   class Foo
-#     if 0
-#       # This method is ignored
-#       def xyz; end
-#     end
-#   end
-class YARD::Handlers::Ruby::ClassConditionHandler < YARD::Handlers::Ruby::Base
-  handles meta_type(:condition)
-  namespace_only
-
-  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)
-  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.condition.type
-    when :int
-      condition = statement.condition[0] != "0"
-    when :defined
-      # 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.
-      arg = statement.condition.first
-
-      if arg.type == :var_ref
-        name = arg.source
-        obj = YARD::Registry.resolve(namespace, name, true)
-
-        begin
-          condition = true if obj || (name && Object.instance_eval("defined? #{name}"))
-        rescue SyntaxError, NameError
-          condition = false
-        end
-      end
-    when :var_ref
-      var = statement.condition[0]
-      if var == s(:kw, "true")
-        condition = true
-      elsif var == s(:kw, "false")
-        condition = false
-      end
-    end
-
-    # Invert an unless condition
-    if statement.type == :unless || statement.type == :unless_mod
-      condition = !condition unless condition.nil?
-    end
-    condition
-  end
-
-  def parse_then_block
-    parse_block(statement.then_block, :visibility => visibility)
-  end
-
-  def parse_else_block
-    if statement.else_block
-      parse_block(statement.else_block, :visibility => visibility)
-    end
-  end
-end
+# frozen_string_literal: true
+# Matches if/unless conditions inside classes and attempts to process only
+# one branch (by evaluating the condition if possible).
+#
+# @example A simple class conditional
+#   class Foo
+#     if 0
+#       # This method is ignored
+#       def xyz; end
+#     end
+#   end
+class YARD::Handlers::Ruby::ClassConditionHandler < YARD::Handlers::Ruby::Base
+  handles meta_type(:condition)
+  namespace_only
+
+  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)
+  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.condition.type
+    when :int
+      condition = statement.condition[0] != "0"
+    when :defined
+      # 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.
+      arg = statement.condition.first
+
+      if arg.type == :var_ref
+        name = arg.source
+        obj = YARD::Registry.resolve(namespace, name, true)
+
+        begin
+          condition = true if obj || (name && Object.instance_eval("defined? #{name}"))
+        rescue SyntaxError, NameError
+          condition = false
+        end
+      end
+    when :var_ref
+      var = statement.condition[0]
+      if var == s(:kw, "true")
+        condition = true
+      elsif var == s(:kw, "false")
+        condition = false
+      end
+    end
+
+    # Invert an unless condition
+    if statement.type == :unless || statement.type == :unless_mod
+      condition = !condition unless condition.nil?
+    end
+    condition
+  end
+
+  def parse_then_block
+    parse_block(statement.then_block, :visibility => visibility)
+  end
+
+  def parse_else_block
+    if statement.else_block
+      parse_block(statement.else_block, :visibility => visibility)
+    end
+  end
+end

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

@@ -1,119 +1,119 @@
-# frozen_string_literal: true
-# Handles class declarations
-class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
-  include YARD::Handlers::Ruby::StructHandlerMethods
-  handles :class, :sclass
-  namespace_only
-
-  process do
-    classname = statement[0].source.gsub(/\s/, '')
-    if statement.type == :class
-      superclass = parse_superclass(statement[1])
-      if superclass == "Struct"
-        is_a_struct = true
-        superclass = struct_superclass_name(statement[1]) # refine the superclass if possible
-        create_struct_superclass(superclass, statement[1])
-      end
-      undocsuper = statement[1] && 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_superclass(klass, statement[1])
-      elsif klass
-        create_attributes(klass, members_from_tags(klass))
-      end
-      parse_block(statement[2], :namespace => klass)
-
-      if undocsuper
-        raise YARD::Parser::UndocumentableError, 'superclass (class was added without superclass)'
-      end
-    elsif statement.type == :sclass
-      if statement[0] == s(:var_ref, s(:kw, "self"))
-        parse_block(statement[1], :namespace => namespace, :scope => :class)
-      else
-        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[0, 1] =~ /[A-Z]/
-          register ClassObject.new(namespace, classname) if Proxy === proxy
-          parse_block(statement[1], :namespace => proxy, :scope => :class)
-        else
-          raise YARD::Parser::UndocumentableError, "class '#{classname}'"
-        end
-      end
-    else
-      sig_end = (statement[1] ? statement[1].source_end : statement[0].source_end) - statement.source_start
-      raise YARD::Parser::UndocumentableError, "class: #{statement.source[0..sig_end]}"
-    end
-  end
-
-  private
-
-  # Extract the parameters from the Struct.new AST node, returning them as a list
-  # of strings
-  #
-  # @param [MethodCallNode] superclass the AST node for the Struct.new call
-  # @return [Array<String>] the member names to generate methods for
-  def extract_parameters(superclass)
-    members = superclass.parameters.select {|x| x && x.type == :symbol_literal }
-    members.map! {|x| x.source.strip[1..-1] }
-    members
-  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_superclass(the_super, superclass_def)
-    the_super
-  end
-
-  def struct_superclass_name(superclass)
-    if superclass.call?
-      first = superclass.parameters.first
-      if first.type == :string_literal && first[0].type == :string_content && first[0].size == 1
-        return "Struct::#{first[0][0][0]}"
-      end
-    end
-    "Struct"
-  end
-
-  def parse_struct_superclass(klass, superclass)
-    return unless superclass.call? && superclass.parameters
-    members = extract_parameters(superclass)
-    create_attributes(klass, members)
-  end
-
-  def parse_superclass(superclass)
-    return nil unless superclass
-
-    case superclass.type
-    when :var_ref
-      return namespace.path if superclass.first == s(:kw, "self")
-      return superclass.source if superclass.first.type == :const
-    when :const, :const_ref, :const_path_ref, :top_const_ref
-      return superclass.source
-    when :fcall, :command
-      methname = superclass.method_name.source
-      return superclass.parameters.first.source if methname == "DelegateClass"
-      return methname if superclass.method_name.type == :const
-    when :call, :command_call
-      cname = superclass.namespace.source
-      if cname =~ /^O?Struct$/ && superclass.method_name(true) == :new
-        return cname
-      end
-    end
-    nil
-  end
-end
+# frozen_string_literal: true
+# Handles class declarations
+class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base
+  include YARD::Handlers::Ruby::StructHandlerMethods
+  handles :class, :sclass
+  namespace_only
+
+  process do
+    classname = statement[0].source.gsub(/\s/, '')
+    if statement.type == :class
+      superclass = parse_superclass(statement[1])
+      if superclass == "Struct"
+        is_a_struct = true
+        superclass = struct_superclass_name(statement[1]) # refine the superclass if possible
+        create_struct_superclass(superclass, statement[1])
+      end
+      undocsuper = statement[1] && 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_superclass(klass, statement[1])
+      elsif klass
+        create_attributes(klass, members_from_tags(klass))
+      end
+      parse_block(statement[2], :namespace => klass)
+
+      if undocsuper
+        raise YARD::Parser::UndocumentableError, 'superclass (class was added without superclass)'
+      end
+    elsif statement.type == :sclass
+      if statement[0] == s(:var_ref, s(:kw, "self"))
+        parse_block(statement[1], :namespace => namespace, :scope => :class)
+      else
+        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[0, 1] =~ /[A-Z]/
+          register ClassObject.new(namespace, classname) if Proxy === proxy
+          parse_block(statement[1], :namespace => proxy, :scope => :class)
+        else
+          raise YARD::Parser::UndocumentableError, "class '#{classname}'"
+        end
+      end
+    else
+      sig_end = (statement[1] ? statement[1].source_end : statement[0].source_end) - statement.source_start
+      raise YARD::Parser::UndocumentableError, "class: #{statement.source[0..sig_end]}"
+    end
+  end
+
+  private
+
+  # Extract the parameters from the Struct.new AST node, returning them as a list
+  # of strings
+  #
+  # @param [MethodCallNode] superclass the AST node for the Struct.new call
+  # @return [Array<String>] the member names to generate methods for
+  def extract_parameters(superclass)
+    members = superclass.parameters.select {|x| x && x.type == :symbol_literal }
+    members.map! {|x| x.source.strip[1..-1] }
+    members
+  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_superclass(the_super, superclass_def)
+    the_super
+  end
+
+  def struct_superclass_name(superclass)
+    if superclass.call?
+      first = superclass.parameters.first
+      if first.type == :string_literal && first[0].type == :string_content && first[0].size == 1
+        return "Struct::#{first[0][0][0]}"
+      end
+    end
+    "Struct"
+  end
+
+  def parse_struct_superclass(klass, superclass)
+    return unless superclass.call? && superclass.parameters
+    members = extract_parameters(superclass)
+    create_attributes(klass, members)
+  end
+
+  def parse_superclass(superclass)
+    return nil unless superclass
+
+    case superclass.type
+    when :var_ref
+      return namespace.path if superclass.first == s(:kw, "self")
+      return superclass.source if superclass.first.type == :const
+    when :const, :const_ref, :const_path_ref, :top_const_ref
+      return superclass.source
+    when :fcall, :command
+      methname = superclass.method_name.source
+      return superclass.parameters.first.source if methname == "DelegateClass"
+      return methname if superclass.method_name.type == :const
+    when :call, :command_call
+      cname = superclass.namespace.source
+      if cname =~ /^O?Struct$/ && superclass.method_name(true) == :new
+        return cname
+      end
+    end
+    nil
+  end
+end

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

@@ -1,17 +1,17 @@
-# frozen_string_literal: true
-# Handles a class variable (@@variable)
-class YARD::Handlers::Ruby::ClassVariableHandler < YARD::Handlers::Ruby::Base
-  handles :assign
-  namespace_only
-
-  process do
-    if statement[0].type == :var_field && statement[0][0].type == :cvar
-      name = statement[0][0][0]
-      value = statement[1].source
-      register ClassVariableObject.new(namespace, name) do |o|
-        o.source = statement
-        o.value = value
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+# Handles a class variable (@@variable)
+class YARD::Handlers::Ruby::ClassVariableHandler < YARD::Handlers::Ruby::Base
+  handles :assign
+  namespace_only
+
+  process do
+    if statement[0].type == :var_field && statement[0][0].type == :cvar
+      name = statement[0][0][0]
+      value = statement[1].source
+      register ClassVariableObject.new(namespace, name) do |o|
+        o.source = statement
+        o.value = value
+      end
+    end
+  end
+end