code-ruby 3.1.2 → 4.0.1

data/lib/code/format.rb

@@ -214,6 +214,7 @@ class Code
       literal = %("#{content}")
       return literal if literal.length <= string_inline_limit(indent)
       return literal unless allow_split
+      return literal if content.include?("\\")
 
       split_string_literal(components, indent: indent)
     end
@@ -331,7 +332,7 @@ class Code
     def format_dictionary_statement_code(statement_code)
       key =
         format_dictionary_statement_key(statement_code[:statement]) ||
-        format_nested_statement(statement_code[:statement], indent: 0)
+          format_nested_statement(statement_code[:statement], indent: 0)
       return key unless statement_code.key?(:code)
 
       value = format_code_inline(statement_code[:code], indent: 0)
@@ -380,6 +381,14 @@ class Code
         return format_code_inline(Array(argument), indent: 0)
       end
 
+      if argument.key?(:operator)
+        return argument[:operator].to_s unless argument.key?(:value)
+
+        value = format_code_inline(argument[:value], indent: 0)
+
+        return "#{argument[:operator]}#{value}"
+      end
+
       value = format_code_inline(argument[:value], indent: 0)
       return value unless argument.key?(:name)
 
@@ -423,6 +432,8 @@ class Code
           parameter[:spread]
         elsif parameter.key?(:block)
           parameter[:block]
+        elsif parameter.key?(:blocks)
+          parameter[:blocks]
         else
           ""
         end
@@ -463,14 +474,17 @@ class Code
               first_line, *rest = right.lines(chomp: true)
               if multiline_operand_statement?(other[:statement]) ||
                    !BOOLEAN_WORD_OPERATORS.include?(operator)
-                ["#{expression} #{operator} #{first_line.lstrip}", *rest].join("\n")
+                ["#{expression} #{operator} #{first_line.lstrip}", *rest].join(
+                  "\n"
+                )
               else
                 [
                   "#{expression}\n#{INDENT * (indent + 1)}#{operator} #{first_line.lstrip}",
                   *rest
                 ].join("\n")
               end
-            elsif expression.include?("\n") || candidate.length > MAX_LINE_LENGTH
+            elsif expression.include?("\n") ||
+                  candidate.length > MAX_LINE_LENGTH
               right_lines =
                 if right.include?("\n")
                   right.lines(chomp: true).map(&:lstrip)
@@ -507,10 +521,9 @@ class Code
       return false if expression.lstrip.start_with?("(")
 
       continuation_lines =
-        expression
-          .lines(chomp: true)[1..]
-          .to_a
-          .reject { |line| line.strip.empty? || line.strip.match?(/\A[\])}]+\z/) }
+        expression.lines(chomp: true)[1..].to_a.reject do |line|
+          line.strip.empty? || line.strip.match?(/\A[\])}]+\z/)
+        end
 
       return false if continuation_lines.empty?
 
@@ -564,10 +577,7 @@ class Code
         first_line = first_line.lstrip
         return "#{left} #{operator} #{first_line}" if rest.empty?
 
-        return [
-          "#{left} #{operator} #{first_line}",
-          *rest
-        ].join("\n")
+        return ["#{left} #{operator} #{first_line}", *rest].join("\n")
       end
 
       "#{left} #{operator} #{right}"
@@ -580,7 +590,9 @@ class Code
         if nested_operator == "="
           left = format_nested_statement(nested[:left], indent: indent)
           right = format_nested_statement(nested[:right], indent: indent)
-          return "#{left} #{nested_operator} #{group_multiline_expression(right, indent: indent)}"
+          return(
+            "#{left} #{nested_operator} #{group_multiline_expression(right, indent: indent)}"
+          )
         end
       end
 
@@ -710,7 +722,8 @@ class Code
           Array(while_statement[:parameters]).map do |parameter|
             format_parameter(parameter, indent: indent)
           end
-        header = parameters.empty? ? "loop {" : "loop { |#{parameters.join(", ")}|"
+        header =
+          parameters.empty? ? "loop {" : "loop { |#{parameters.join(", ")}|"
 
         return "#{INDENT * indent}#{header}\n#{body}\n#{INDENT * indent}}"
       end
@@ -743,7 +756,9 @@ class Code
         others = Array(operation[:others])
 
         return false if others.empty?
-        return false unless others.all? { |other| compact_operator?(other[:operator]) }
+        unless others.all? { |other| compact_operator?(other[:operator]) }
+          return false
+        end
 
         return multiline_operand_statement?(operation[:first])
       end
@@ -771,7 +786,10 @@ class Code
 
     def indent_lines(value, indent)
       prefix = INDENT * indent
-      value.split("\n").map { |line| line.empty? ? "" : "#{prefix}#{line}" }.join("\n")
+      value
+        .split("\n")
+        .map { |line| line.empty? ? "" : "#{prefix}#{line}" }
+        .join("\n")
     end
 
     def statement_separator(inline:, indent: nil)

data/lib/code/network.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class Code
+  module Network
+    BLOCKED_HOSTS = %w[localhost localhost.localdomain].freeze
+    BLOCKED_HOST_SUFFIXES = %w[.local .localhost].freeze
+    BLOCKED_IP_RANGES =
+      %w[
+        0.0.0.0/8
+        10.0.0.0/8
+        100.64.0.0/10
+        127.0.0.0/8
+        169.254.0.0/16
+        172.16.0.0/12
+        192.0.0.0/24
+        192.168.0.0/16
+        224.0.0.0/4
+        240.0.0.0/4
+        ::/128
+        ::1/128
+        64:ff9b::/96
+        64:ff9b:1::/48
+        2002::/16
+        fc00::/7
+        fe80::/10
+        ff00::/8
+      ].map { |range| IPAddr.new(range) }.freeze
+
+    def self.validate_public_uri!(uri, service:)
+      unless %w[http https].include?(uri.scheme)
+        raise Error, "#{service}: unsupported url scheme"
+      end
+
+      validate_public_host!(uri.hostname, service: service).first
+    end
+
+    def self.validate_public_host!(host, service:)
+      normalized_host = normalize_host(host)
+
+      if blocked_hostname?(normalized_host)
+        raise Error, "#{service}: local network requests are not allowed"
+      end
+
+      addresses = resolved_addresses(normalized_host)
+      raise Error, "#{service}: could not resolve host" if addresses.empty?
+
+      if addresses.any? { |address| blocked_address?(address) }
+        raise Error, "#{service}: local network requests are not allowed"
+      end
+
+      addresses
+    rescue Resolv::ResolvError, ArgumentError
+      raise Error, "#{service}: could not resolve host"
+    end
+
+    def self.blocked_address?(address)
+      ip = IPAddr.new(address)
+      ip = ip.native if ip.respond_to?(:ipv4_mapped?) && ip.ipv4_mapped?
+      ip = ip.native if ip.respond_to?(:ipv4_compat?) && ip.ipv4_compat?
+
+      BLOCKED_IP_RANGES.any? { |range| range.include?(ip) }
+    end
+
+    def self.resolved_addresses(host)
+      [IPAddr.new(host).to_s]
+    rescue ArgumentError
+      Resolv.getaddresses(host)
+    end
+
+    def self.normalize_host(host)
+      normalized_host = host.to_s.downcase.delete_suffix(".")
+      raise Error, "network: invalid host" if normalized_host.blank?
+
+      normalized_host
+    end
+
+    def self.blocked_hostname?(host)
+      BLOCKED_HOSTS.include?(host) ||
+        BLOCKED_HOST_SUFFIXES.any? { |suffix| host.end_with?(suffix) }
+    end
+  end
+end

data/lib/code/node/call.rb

@@ -36,7 +36,9 @@ class Code
         arguments = []
 
         (@arguments || []).each do |argument|
-          if argument.keyword?
+          if argument.expansion?
+            append_expanded_argument(arguments, argument, **args)
+          elsif argument.keyword?
             if arguments.last.is_a?(Object::Dictionary)
               arguments.last.code_merge!(argument.evaluate(**args))
             else
@@ -51,7 +53,18 @@ class Code
 
         name = Object::String.new(@name)
 
-        args.fetch(:object).call(
+        object = args.fetch(:object)
+        dynamic_result =
+          object.code_dynamic_call(
+            name,
+            operator: name,
+            arguments: Object::List.new(arguments),
+            explicit_arguments: @explicit_arguments,
+            **args
+          )
+        return dynamic_result if dynamic_result
+
+        object.call(
           operator: name,
           arguments: Object::List.new(arguments),
           explicit_arguments: @explicit_arguments,
@@ -62,6 +75,71 @@ class Code
       def resolve(**_args)
         Object::String.new(@name)
       end
+
+      private
+
+      def append_expanded_argument(arguments, argument, **args)
+        value =
+          if argument.value?
+            argument.evaluate(**args)
+          else
+            default_forwarded_argument(argument.operator, args.fetch(:context))
+          end
+        return if value.nil?
+
+        case argument.operator
+        when "*", "&&"
+          value.to_code.code_to_list.raw.each { |item| arguments << item }
+        when "**"
+          dictionary = value.to_code.code_to_dictionary
+          if arguments.last.is_a?(Object::Dictionary)
+            arguments.last.code_merge!(dictionary)
+          else
+            arguments << dictionary
+          end
+        when "&"
+          code_value = value.to_code
+          arguments << if code_value.is_a?(Object::Function) ||
+               code_value.nothing?
+            code_value
+          else
+            code_value.call(operator: "&", **args)
+          end
+        when "..."
+          expanded_arguments(value, args.fetch(:context)).each do |item|
+            arguments << item
+          end
+        end
+      end
+
+      def default_forwarded_argument(operator, context)
+        case operator
+        when "*"
+          context_fetch(context, "arguments") || Object::List.new
+        when "**"
+          context_fetch(context, "keyword_arguments")
+        when "&"
+          context_fetch(context, "block")
+        when "&&"
+          context_fetch(context, "blocks") || Object::List.new
+        when "..."
+          context_fetch(context, "rest") || Object::List.new
+        end
+      end
+
+      def context_fetch(context, name)
+        context.code_lookup!(name).code_fetch(name)
+      rescue Error
+        nil
+      end
+
+      def expanded_arguments(value, context)
+        if value.nothing?
+          context.code_lookup!("rest").code_fetch("rest").code_to_list.raw
+        else
+          value.to_code.code_to_list.raw
+        end
+      end
     end
   end
 end

data/lib/code/node/call_argument.rb

@@ -6,8 +6,10 @@ class Code
       def initialize(parsed)
         return if parsed.blank?
 
+        @has_value = parsed[:value].present?
         @value = Node::Code.new(parsed.delete(:value).presence)
         @name = parsed.delete(:name).presence
+        @operator = parsed.delete(:operator).presence
       end
 
       def evaluate(**args)
@@ -20,10 +22,22 @@ class Code
         end
       end
 
+      def operator
+        @operator.to_s
+      end
+
+      def expansion?
+        operator.present?
+      end
+
       def keyword?
         !!@name
       end
 
+      def value?
+        !!@has_value
+      end
+
       def regular?
         !keyword?
       end

data/lib/code/node/code.rb

@@ -21,11 +21,11 @@ class Code
             args
           end
         last = Object::Nothing.new
+        root_object = args.fetch(:root_object, args.fetch(:object))
 
         begin
           (@statements || []).each do |statement|
-            last =
-              statement.evaluate(**statement_args, object: Object::Global.new)
+            last = statement.evaluate(**statement_args, object: root_object)
           end
         rescue Error::Retry
           retry if control_flow_scope == :group
@@ -48,9 +48,10 @@ class Code
 
       def resolve(**args)
         last = Object::Nothing.new
+        root_object = args.fetch(:root_object, args.fetch(:object))
 
         (@statements || []).each do |statement|
-          last = statement.resolve(**args, object: Object::Global.new)
+          last = statement.resolve(**args, object: root_object)
         end
 
         last

data/lib/code/node/function_parameter.rb

@@ -8,15 +8,13 @@ class Code
       def initialize(parsed)
         return if parsed.blank?
 
-        @name =
-          parsed.delete(:name).presence || parsed[:regular_splat].presence ||
-            parsed[:keyword_splat].presence || parsed[:spread].presence ||
-            parsed[:block].presence
+        @name = parsed.delete(:name).presence
         @keyword = parsed.delete(:keyword).present?
         @regular_splat = parsed.delete(:regular_splat).present?
         @keyword_splat = parsed.delete(:keyword_splat).present?
         @spread = parsed.delete(:spread).present?
         @block = parsed.delete(:block).present?
+        @blocks = parsed.delete(:blocks).present?
         @default = Code.new(parsed.delete(:default)) if parsed.key?(:default)
       end
 
@@ -48,6 +46,10 @@ class Code
         !!@block
       end
 
+      def blocks?
+        !!@blocks
+      end
+
       def to_h
         {
           name: name,
@@ -57,6 +59,7 @@ class Code
           keyword_splat?: keyword_splat?,
           spread?: spread?,
           block?: block?,
+          blocks?: blocks?,
           default: default
         }
       end

data/lib/code/node/list.rb

@@ -11,10 +11,40 @@ class Code
       end
 
       def evaluate(**args)
-        ::Code::Object::List.new(
-          (@elements || []).map { |element| element.evaluate(**args) }
+        list =
+          ::Code::Object::List.new(
+            (@elements || []).map { |element| element.evaluate(**args) }
+          )
+        constructor = literal_constructor(args.fetch(:context), "List")
+        return list unless constructor
+        if Array(args[:constructing_literal_classes]).include?(
+             ::Code::Object::List
+           )
+          return list
+        end
+
+        constructor.call(
+          **args,
+          constructing_literal_classes:
+            Array(args[:constructing_literal_classes]) + [::Code::Object::List],
+          operator: nil,
+          arguments: ::Code::Object::List.new([list]),
+          explicit_arguments: true
         )
       end
+
+      private
+
+      def literal_constructor(context, name)
+        return unless context.code_has_key?(name).truthy?
+
+        constructor = context.code_fetch(name)
+        return unless constructor.is_a?(::Code::Object::Function)
+        return unless constructor.parent.is_a?(::Code::Object::Class)
+        return unless constructor.parent.raw == ::Code::Object::List
+
+        constructor
+      end
     end
   end
 end

data/lib/code/node/square_bracket.rb

@@ -13,7 +13,8 @@ class Code
 
       def evaluate(**args)
         left = @left&.evaluate(**args) || Object::Nothing.new
-        index_args = args.merge(object: args.fetch(:previous_object, args.fetch(:object)))
+        index_args =
+          args.merge(object: args.fetch(:previous_object, args.fetch(:object)))
 
         (@statements || []).reduce(left) do |object, statement|
           object.code_fetch(statement.evaluate(**index_args))
@@ -30,7 +31,8 @@ class Code
             Object::IdentifierList.new([left])
           end
 
-        index_args = args.merge(object: args.fetch(:previous_object, args.fetch(:object)))
+        index_args =
+          args.merge(object: args.fetch(:previous_object, args.fetch(:object)))
 
         (@statements || []).each do |statement|
           list.code_append(statement.evaluate(**index_args))

data/lib/code/object/base_64.rb

@@ -3,28 +3,154 @@
 class Code
   class Object
     class Base64 < Object
+      CLASS_DOCUMENTATION = {
+        name: "Base64",
+        description: "encodes and decodes strings with base64 text formats.",
+        examples: [
+          "Base64.encode(:hello)",
+          "Base64.decode(Base64.encode(:hello))",
+          "Base64.urlsafe_decode(Base64.urlsafe_encode(\"???\"))"
+        ]
+      }.freeze
+      CLASS_FUNCTIONS = {
+        "encode" => {
+          name: "encode",
+          description: "returns base64 text with line breaks for a string.",
+          examples: [
+            "Base64.encode(:hello)",
+            "Base64.encode(:hello_world)",
+            "Base64.encode(\"123\")"
+          ]
+        },
+        "encode_64" => {
+          name: "encode_64",
+          description: "returns base64 text with line breaks for a string.",
+          examples: [
+            "Base64.encode_64(:hello)",
+            "Base64.encode_64(:hello_world)",
+            "Base64.encode_64(\"123\")"
+          ]
+        },
+        "decode" => {
+          name: "decode",
+          description: "returns a string decoded from base64 text.",
+          examples: [
+            "Base64.decode(\"aGVsbG8=\")",
+            "Base64.decode(Base64.encode(:hello))",
+            "Base64.decode(\"MTIz\")"
+          ]
+        },
+        "decode_64" => {
+          name: "decode_64",
+          description: "returns a string decoded from base64 text.",
+          examples: [
+            "Base64.decode_64(\"aGVsbG8=\")",
+            "Base64.decode_64(Base64.encode(:hello))",
+            "Base64.decode_64(\"MTIz\")"
+          ]
+        },
+        "strict_encode" => {
+          name: "strict_encode",
+          description: "returns base64 text without line breaks for a string.",
+          examples: [
+            "Base64.strict_encode(:hello)",
+            "Base64.strict_encode(:hello_world)",
+            "Base64.strict_encode(\"123\")"
+          ]
+        },
+        "strict_encode_64" => {
+          name: "strict_encode_64",
+          description: "returns base64 text without line breaks for a string.",
+          examples: [
+            "Base64.strict_encode_64(:hello)",
+            "Base64.strict_encode_64(:hello_world)",
+            "Base64.strict_encode_64(\"123\")"
+          ]
+        },
+        "strict_decode" => {
+          name: "strict_decode",
+          description: "returns a string decoded from strict base64 text.",
+          examples: [
+            "Base64.strict_decode(\"aGVsbG8=\")",
+            "Base64.strict_decode(Base64.strict_encode(:hello))",
+            "Base64.strict_decode(\"MTIz\")"
+          ]
+        },
+        "strict_decode_64" => {
+          name: "strict_decode_64",
+          description: "returns a string decoded from strict base64 text.",
+          examples: [
+            "Base64.strict_decode_64(\"aGVsbG8=\")",
+            "Base64.strict_decode_64(Base64.strict_encode(:hello))",
+            "Base64.strict_decode_64(\"MTIz\")"
+          ]
+        },
+        "urlsafe_encode" => {
+          name: "urlsafe_encode",
+          description: "returns url-safe base64 text for a string.",
+          examples: [
+            "Base64.urlsafe_encode(:hello)",
+            "Base64.urlsafe_encode(\">>>\")",
+            "Base64.urlsafe_encode(\"???\")"
+          ]
+        },
+        "url_safe_encode_64" => {
+          name: "url_safe_encode_64",
+          description: "returns url-safe base64 text for a string.",
+          examples: [
+            "Base64.url_safe_encode_64(:hello)",
+            "Base64.url_safe_encode_64(\">>>\")",
+            "Base64.url_safe_encode_64(\"???\")"
+          ]
+        },
+        "urlsafe_decode" => {
+          name: "urlsafe_decode",
+          description: "returns a string decoded from url-safe base64 text.",
+          examples: [
+            "Base64.urlsafe_decode(\"aGVsbG8=\")",
+            "Base64.urlsafe_decode(\"Pj4-\")",
+            "Base64.urlsafe_decode(\"Pz8_\")"
+          ]
+        },
+        "url_safe_decode_64" => {
+          name: "url_safe_decode_64",
+          description: "returns a string decoded from url-safe base64 text.",
+          examples: [
+            "Base64.url_safe_decode_64(\"aGVsbG8=\")",
+            "Base64.url_safe_decode_64(\"Pj4-\")",
+            "Base64.url_safe_decode_64(\"Pz8_\")"
+          ]
+        }
+      }.freeze
+
+      def self.function_documentation(scope)
+        return CLASS_FUNCTIONS if scope == :class
+
+        {}
+      end
+
       def self.call(**args)
         code_operator = args.fetch(:operator, nil).to_code
         code_arguments = args.fetch(:arguments, []).to_code
         code_value = code_arguments.code_first
 
         case code_operator.to_s
-        when "encode"
+        when "encode", "encode_64"
           sig(args) { String }
           code_encode(code_value)
-        when "decode"
+        when "decode", "decode_64"
           sig(args) { String }
           code_decode(code_value)
-        when "strict_encode"
+        when "strict_encode", "strict_encode_64"
           sig(args) { String }
           code_strict_encode(code_value)
-        when "strict_decode"
+        when "strict_decode", "strict_decode_64"
           sig(args) { String }
           code_strict_decode(code_value)
-        when "urlsafe_encode"
+        when "urlsafe_encode", "url_safe_encode_64"
           sig(args) { String }
           code_urlsafe_encode(code_value)
-        when "urlsafe_decode"
+        when "urlsafe_decode", "url_safe_decode_64"
           sig(args) { String }
           code_urlsafe_decode(code_value)
         else