code-ruby 3.1.2 → 4.0.0

data/lib/code/network.rb

@@ -0,0 +1,87 @@
+# 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 = [
+      "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,17 @@ 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 +74,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

@@ -19,13 +19,13 @@ class Code
             args.merge(global_control_flow_root: false)
           else
             args
-          end
+        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,9 +11,37 @@ class Code
       end
 
       def evaluate(**args)
-        ::Code::Object::List.new(
+        list = ::Code::Object::List.new(
           (@elements || []).map { |element| element.evaluate(**args) }
         )
+        constructor = literal_constructor(args.fetch(:context), "List")
+        return list unless constructor
+        return list if Array(args[:constructing_literal_classes]).include?(
+          ::Code::Object::List
+        )
+
+        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

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

data/lib/code/object/boolean.rb

@@ -3,6 +3,66 @@
 class Code
   class Object
     class Boolean < ::Code::Object
+      CLASS_DOCUMENTATION = {
+        name: "Boolean",
+        description: "represents true or false.",
+        examples: [
+          "Boolean",
+          "Boolean.new(true)",
+          "Boolean.new(false)"
+        ]
+      }.freeze
+      INSTANCE_FUNCTIONS = {
+        "&" => {
+          name: "&",
+          description: "returns true when both booleans are true.",
+          examples: ["true & true", "true & false", "false & false"]
+        },
+        "bitwise_and" => {
+          name: "bitwise_and",
+          description: "returns true when both booleans are true.",
+          examples: [
+            "true.bitwise_and(true)",
+            "true.bitwise_and(false)",
+            "false.bitwise_and(false)"
+          ]
+        },
+        "|" => {
+          name: "|",
+          description: "returns true when either boolean is true.",
+          examples: ["true | false", "false | true", "false | false"]
+        },
+        "bitwise_or" => {
+          name: "bitwise_or",
+          description: "returns true when either boolean is true.",
+          examples: [
+            "true.bitwise_or(false)",
+            "false.bitwise_or(true)",
+            "false.bitwise_or(false)"
+          ]
+        },
+        "^" => {
+          name: "^",
+          description: "returns true when exactly one boolean is true.",
+          examples: ["true ^ false", "true ^ true", "false ^ false"]
+        },
+        "bitwise_xor" => {
+          name: "bitwise_xor",
+          description: "returns true when exactly one boolean is true.",
+          examples: [
+            "true.bitwise_xor(false)",
+            "true.bitwise_xor(true)",
+            "false.bitwise_xor(false)"
+          ]
+        }
+      }.freeze
+
+      def self.function_documentation(scope)
+        return INSTANCE_FUNCTIONS if scope == :instance
+
+        {}
+      end
+
       def initialize(*args, **_kargs, &_block)
         self.raw =
           (args.first.is_an?(Object) ? args.first.truthy? : !!args.first)