Nodoc some private functions/modules

Author: Earlopain

lib/prism/parse_result.rb

@@ -163,7 +163,7 @@ def deep_freeze
 
     # Binary search through the offsets to find the line number for the given
     # byte offset.
-    def find_line(byte_offset)
+    def find_line(byte_offset) # :nodoc:
       index = offsets.bsearch_index { |offset| offset > byte_offset } || offsets.length
       index - 1
     end

lib/prism/pattern.rb

@@ -100,23 +100,23 @@ def scan(root)
 
     # Shortcut for combining two procs into one that returns true if both return
     # true.
-    def combine_and(left, right)
+    def combine_and(left, right) # :nodoc:
       ->(other) { left.call(other) && right.call(other) }
     end
 
     # Shortcut for combining two procs into one that returns true if either
     # returns true.
-    def combine_or(left, right)
+    def combine_or(left, right) # :nodoc:
       ->(other) { left.call(other) || right.call(other) }
     end
 
     # Raise an error because the given node is not supported.
-    def compile_error(node)
+    def compile_error(node) # :nodoc:
       raise CompilationError, node.inspect
     end
 
     # in [foo, bar, baz]
-    def compile_array_pattern_node(node)
+    def compile_array_pattern_node(node) # :nodoc:
       compile_error(node) if !node.rest.nil? || node.posts.any?
 
       constant = node.constant
@@ -141,12 +141,12 @@ def compile_array_pattern_node(node)
     end
 
     # in foo | bar
-    def compile_alternation_pattern_node(node)
+    def compile_alternation_pattern_node(node) # :nodoc:
       combine_or(compile_node(node.left), compile_node(node.right))
     end
 
     # in Prism::ConstantReadNode
-    def compile_constant_path_node(node)
+    def compile_constant_path_node(node) # :nodoc:
       parent = node.parent
 
       if parent.is_a?(ConstantReadNode) && parent.slice == "Prism"
@@ -161,12 +161,12 @@ def compile_constant_path_node(node)
 
     # in ConstantReadNode
     # in String
-    def compile_constant_read_node(node)
+    def compile_constant_read_node(node) # :nodoc:
       compile_constant_name(node, node.name)
     end
 
     # Compile a name associated with a constant.
-    def compile_constant_name(node, name)
+    def compile_constant_name(node, name) # :nodoc:
       if Prism.const_defined?(name, false)
         clazz = Prism.const_get(name)
 
@@ -182,7 +182,7 @@ def compile_constant_name(node, name)
 
     # in InstanceVariableReadNode[name: Symbol]
     # in { name: Symbol }
-    def compile_hash_pattern_node(node)
+    def compile_hash_pattern_node(node) # :nodoc:
       compile_error(node) if node.rest
       compiled_constant = compile_node(node.constant) if node.constant
 
@@ -212,36 +212,36 @@ def compile_hash_pattern_node(node)
     end
 
     # in nil
-    def compile_nil_node(node)
+    def compile_nil_node(node) # :nodoc:
       ->(attribute) { attribute.nil? }
     end
 
     # in /foo/
-    def compile_regular_expression_node(node)
+    def compile_regular_expression_node(node) # :nodoc:
       regexp = Regexp.new(node.unescaped, node.closing[1..])
 
       ->(attribute) { regexp === attribute }
     end
 
     # in ""
     # in "foo"
-    def compile_string_node(node)
+    def compile_string_node(node) # :nodoc:
       string = node.unescaped
 
       ->(attribute) { string === attribute }
     end
 
     # in :+
     # in :foo
-    def compile_symbol_node(node)
+    def compile_symbol_node(node) # :nodoc:
       symbol = node.unescaped.to_sym
 
       ->(attribute) { symbol === attribute }
     end
 
     # Compile any kind of node. Dispatch out to the individual compilation
     # methods based on the type of node.
-    def compile_node(node)
+    def compile_node(node) # :nodoc:
       case node
       when AlternationPatternNode
         compile_alternation_pattern_node(node)

templates/lib/prism/dispatcher.rb.erb

@@ -56,7 +56,7 @@ module Prism
     end
 
     # Register a listener for the given events.
-    private def register_events(listener, events)
+    private def register_events(listener, events) # :nodoc:
       events.each { |event| (listeners[event] ||= []) << listener }
     end
 

templates/lib/prism/dot_visitor.rb.erb

@@ -165,19 +165,19 @@ module Prism
     private
 
     # Generate a unique node ID for a node throughout the digraph.
-    def node_id(node)
+    def node_id(node) # :nodoc:
       "Node_#{node.object_id}"
     end
 
     # Inspect a location to display the start and end line and columns in bytes.
-    def location_inspect(location)
+    def location_inspect(location) # :nodoc:
       "(#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column})"
     end
     <%- flags.each do |flag| -%>
 
     # Inspect a node that has <%= flag.human %> flags to display the flags as a
     # comma-separated list.
-    def <%= flag.human %>_inspect(node)
+    def <%= flag.human %>_inspect(node) # :nodoc:
       flags = [] #: Array[String]
       <%- flag.values.each do |value| -%>
       flags << "<%= value.name.downcase %>" if node.<%= value.name.downcase %>?

templates/lib/prism/inspect_visitor.rb.erb

@@ -114,13 +114,13 @@ module Prism
     private
 
     # Compose a header for the given node.
-    def inspect_node(name, node)
+    def inspect_node(name, node) # :nodoc:
       location = node.location
       "@ #{name} (location: (#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column}))\n"
     end
 
     # Compose a string representing the given inner location field.
-    def inspect_location(location)
+    def inspect_location(location) # :nodoc:
       if location
         "(#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column}) = #{location.slice.inspect}"
       else

templates/lib/prism/serialize.rb.erb

@@ -3,7 +3,7 @@ require_relative "polyfill/unpack1"
 
 module Prism
   # A module responsible for deserializing parse results.
-  module Serialize
+  module Serialize # :nodoc:
     # The major version of prism that we are expecting to find in the serialized
     # strings.
     MAJOR_VERSION = 1