Server IP : 66.29.132.122 / Your IP : 3.15.147.65 Web Server : LiteSpeed System : Linux business142.web-hosting.com 4.18.0-553.lve.el8.x86_64 #1 SMP Mon May 27 15:27:34 UTC 2024 x86_64 User : admazpex ( 531) PHP Version : 7.2.34 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /proc/self/root/proc/self/root/proc/thread-self/root/proc/thread-self/root/proc/self/root/proc/thread-self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/opt/alt/ruby33/share/ruby/prism/ |
Upload File : |
# frozen_string_literal: true # Here we are reopening the prism module to provide methods on nodes that aren't # templated and are meant as convenience methods. module Prism module RegularExpressionOptions # :nodoc: # Returns a numeric value that represents the flags that were used to create # the regular expression. def options o = flags & (RegularExpressionFlags::IGNORE_CASE | RegularExpressionFlags::EXTENDED | RegularExpressionFlags::MULTI_LINE) o |= Regexp::FIXEDENCODING if flags.anybits?(RegularExpressionFlags::EUC_JP | RegularExpressionFlags::WINDOWS_31J | RegularExpressionFlags::UTF_8) o |= Regexp::NOENCODING if flags.anybits?(RegularExpressionFlags::ASCII_8BIT) o end end class InterpolatedMatchLastLineNode < Node include RegularExpressionOptions end class InterpolatedRegularExpressionNode < Node include RegularExpressionOptions end class MatchLastLineNode < Node include RegularExpressionOptions end class RegularExpressionNode < Node include RegularExpressionOptions end private_constant :RegularExpressionOptions module HeredocQuery # :nodoc: # Returns true if this node was represented as a heredoc in the source code. def heredoc? opening&.start_with?("<<") end end class InterpolatedStringNode < Node include HeredocQuery end class InterpolatedXStringNode < Node include HeredocQuery end class StringNode < Node include HeredocQuery end class XStringNode < Node include HeredocQuery end private_constant :HeredocQuery class FloatNode < Node # Returns the value of the node as a Ruby Float. def value Float(slice) end end class ImaginaryNode < Node # Returns the value of the node as a Ruby Complex. def value Complex(0, numeric.value) end end class IntegerNode < Node # Returns the value of the node as a Ruby Integer. def value Integer(slice) end end class RationalNode < Node # Returns the value of the node as a Ruby Rational. def value Rational(slice.chomp("r")) end end class ConstantReadNode < Node # Returns the list of parts for the full name of this constant. # For example: [:Foo] def full_name_parts [name] end # Returns the full name of this constant. For example: "Foo" def full_name name.name end end class ConstantPathNode < Node # An error class raised when dynamic parts are found while computing a # constant path's full name. For example: # Foo::Bar::Baz -> does not raise because all parts of the constant path are # simple constants # var::Bar::Baz -> raises because the first part of the constant path is a # local variable class DynamicPartsInConstantPathError < StandardError; end # Returns the list of parts for the full name of this constant path. # For example: [:Foo, :Bar] def full_name_parts parts = [child.name] current = parent while current.is_a?(ConstantPathNode) parts.unshift(current.child.name) current = current.parent end unless current.is_a?(ConstantReadNode) raise DynamicPartsInConstantPathError, "Constant path contains dynamic parts. Cannot compute full name" end parts.unshift(current&.name || :"") end # Returns the full name of this constant path. For example: "Foo::Bar" def full_name full_name_parts.join("::") end end class ConstantPathTargetNode < Node # Returns the list of parts for the full name of this constant path. # For example: [:Foo, :Bar] def full_name_parts (parent&.full_name_parts || [:""]).push(child.name) end # Returns the full name of this constant path. For example: "Foo::Bar" def full_name full_name_parts.join("::") end end class ParametersNode < Node # Mirrors the Method#parameters method. def signature names = [] requireds.each do |param| names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name]) end optionals.each { |param| names << [:opt, param.name] } names << [:rest, rest.name || :*] if rest posts.each do |param| names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name]) end # Regardless of the order in which the keywords were defined, the required # keywords always come first followed by the optional keywords. keyopt = [] keywords.each do |param| if param.is_a?(OptionalKeywordParameterNode) keyopt << param else names << [:keyreq, param.name] end end keyopt.each { |param| names << [:key, param.name] } case keyword_rest when ForwardingParameterNode names.concat([[:rest, :*], [:keyrest, :**], [:block, :&]]) when KeywordRestParameterNode names << [:keyrest, keyword_rest.name || :**] when NoKeywordsParameterNode names << [:nokey] end names << [:block, block.name || :&] if block names end end end