code-ruby 5.1.0 → 5.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eec903cbdd5d6368b89062c2b714515f30296bc14da6c56955cfb56883d1c8ec
-  data.tar.gz: efff6f91bce16b5bd93295f694be06337a7edbbfd3c882108ffc0f4b1381be17
+  metadata.gz: 52e251b96064139d4e72a393de2b727b5d792ff0026d3d5f4830e582b54a7573
+  data.tar.gz: 456d6ddc2f99e1d662273af433beaf0461e960be102d829c26a9637af0c29bae
 SHA512:
-  metadata.gz: aaa741df2a2cedebe5db8b763cb0aaac30f5829175baa76a90b4207bbfdb31f2b3eb87cf397eb475ef50e881db24c054e199677f09928f56c359712d5ee83101
-  data.tar.gz: 59c8234dfb28efcb3672fbfb23673bfa5f3748edb92618fc0b5bda474ad700cca898da79f705ce750ac22b47539605544bb5c15d9e53287d872f97e77ffd5d32
+  metadata.gz: bd013119d2df47feb3c438cee2dccb21e13a01ca319085f7a4dc012966efc02a21578b07ccd104e851f5a0d3c633ac45e07ffea4e7dc4ba34e4fd012fb9bbca8
+  data.tar.gz: 057ad7fc9b03bbe40e4c921833e0da2926c0dfb9688b5c63a389cb4e66a687354bebc9591fb95eb8f56f41785fac888d976964c950c88c5532646c164e35c9ed

data/VERSION

@@ -1 +1 @@
-5.1.0
+5.2.2

data/lib/code/format.rb

@@ -459,11 +459,12 @@ class Code
         extract_string_concatenation_parts(left_operation: operation)
       return format_string(merged_string, indent: indent) if merged_string
 
-      expression = format_nested_statement(operation[:first], indent: indent)
+      first_operator = format_operator(Array(operation[:others]).first&.fetch(:operator, ""))
+      expression = format_boolean_operand(operation[:first], first_operator, indent: indent)
 
       Array(operation[:others]).each do |other|
-        right = format_nested_statement(other[:statement], indent: indent)
         operator = format_operator(other[:operator])
+        right = format_boolean_operand(other[:statement], operator, indent: indent)
 
         expression =
           if compact_operator?(operator)
@@ -510,6 +511,21 @@ class Code
       expression
     end
 
+    def format_boolean_operand(statement, operator, indent:)
+      if BOOLEAN_WORD_OPERATORS.include?(operator) && statement.is_a?(Hash) &&
+           statement[:left_operation]
+        nested = Array(statement[:left_operation][:others])
+        if nested.any? do |other|
+             nested_operator = format_operator(other[:operator])
+             BOOLEAN_WORD_OPERATORS.include?(nested_operator) && nested_operator != operator
+           end
+          return format_group([statement], indent: indent)
+        end
+      end
+
+      format_nested_statement(statement, indent: indent)
+    end
+
     def format_compact_receiver(expression, indent:)
       return expression unless compact_receiver_needs_parentheses?(expression)
 

data/lib/code/object/cryptography.rb

@@ -13,7 +13,18 @@ class Code
           "Cryptography.sha512(:hello, format: :base64)"
         ]
       }.freeze
+      HMAC_ALGORITHM = "SHA256"
+      DEFAULT_FORMAT = "hex"
       CLASS_FUNCTIONS = {
+        "hmac_sha256" => {
+          name: "hmac_sha256",
+          description: "returns an HMAC SHA256 signature as hex, digest, or base64.",
+          examples: [
+            'Cryptography.hmac_sha256("key", "hello")',
+            'Cryptography.hmac_sha256("key", "hello", format: :base64)',
+            'Cryptography.hmac_sha256("key", "hello", format: :digest).size'
+          ]
+        },
         "md5" => {
           name: "md5",
           description:
@@ -78,6 +89,9 @@ class Code
         arguments = code_arguments.raw
 
         case code_operator.to_s
+        when "hmac_sha256"
+          sig(args) { [Object, Object, { format: String.maybe }] }
+          code_hmac_sha256(*arguments)
         when "md5"
           sig(args) { [Object, { format: String.maybe }] }
           code_md5(*arguments)
@@ -98,6 +112,22 @@ class Code
         end
       end
 
+      def self.code_hmac_sha256(key, payload, options = nil)
+        code_format = (options || {}).to_code.code_get("format")
+        format = code_format.nothing? ? DEFAULT_FORMAT : code_format.to_s.downcase
+        digest = OpenSSL::HMAC.digest(HMAC_ALGORITHM, key.to_s, payload.to_s)
+        case format
+        when "hex", "hexdigest"
+          digest.unpack1("H*").to_code
+        when "digest"
+          digest.to_code
+        when "base64"
+          ::Base64.strict_encode64(digest).to_code
+        else
+          raise Error, "Cryptography: unknown format #{format.inspect}"
+        end
+      end
+
       def self.code_md5(*arguments)
         payload = arguments[0]
         options = arguments[1] || Nothing.new

data/lib/code/object/http.rb

@@ -197,7 +197,8 @@ class Code
         not_extended: 510,
         network_authentication_required: 511
       }.freeze
-      DEFAULT_TIMEOUT = 1.hour.to_f
+      DEFAULT_TIMEOUT = 30
+      DEFAULT_OPEN_TIMEOUT = 10
       MAX_HEADER_BYTES = 32.kilobytes
       HEADER_NAME = /\A[A-Za-z0-9!#$%&'*+\-.^_`|~]+\z/
       RESTRICTED_HEADERS = %w[
@@ -348,7 +349,7 @@ class Code
           redirects =
             (
               if options.code_get("redirects").nothing?
-                10
+                0
               else
                 options.code_get("redirects").raw
               end
@@ -410,7 +411,11 @@ class Code
         http.use_ssl = true if uri.scheme == "https"
         http.max_retries = max_retries
         default_timeout = http_timeout(timeout, DEFAULT_TIMEOUT)
-        open_timeout_value = http_timeout(open_timeout, default_timeout)
+        open_timeout_value =
+          http_timeout(
+            open_timeout,
+            timeout.nothing? ? DEFAULT_OPEN_TIMEOUT : default_timeout
+          )
         read_timeout_value = http_timeout(read_timeout, default_timeout)
         write_timeout_value = http_timeout(write_timeout, default_timeout)
 

data/lib/code/object/smtp.rb

@@ -8,6 +8,38 @@ class Code
         description: "stores smtp settings and sends email messages.",
         examples: %w[Smtp Smtp.new Smtp.new.functions.keys.include?(:send)]
       }.freeze
+      MESSAGE_ARGUMENTS = {
+        from: String.maybe,
+        to: String.maybe,
+        subject: String.maybe,
+        body: String.maybe,
+        body_text: String.maybe,
+        body_html: String.maybe,
+        message_id: String.maybe
+      }.freeze
+      TEXT_CONTENT_TYPE = "text/plain; charset=UTF-8"
+      HTML_CONTENT_TYPE = "text/html; charset=UTF-8"
+      MULTIPART_CONTENT_TYPE = "multipart/alternative"
+      CLASS_FUNCTIONS = {
+        "encode" => {
+          name: "encode",
+          description: "encodes a message as MIME email.",
+          examples: [
+            'Smtp.encode({from: "a@example.com", to: "b@example.com", body: "hello"})',
+            'Smtp.encode({subject: "hello", body_text: "world"})',
+            'Smtp.encode({body_html: "<p>hello</p>"})'
+          ]
+        },
+        "address" => {
+          name: "address",
+          description: "parses a single email address and display name.",
+          examples: [
+            'Smtp.address("a@example.com")',
+            'Smtp.address("Alice <a@example.com>")',
+            'Smtp.address("Bob <b@example.com>")'
+          ]
+        }
+      }.freeze
       INSTANCE_FUNCTIONS = {
         "send" => {
           name: "send",
@@ -23,7 +55,7 @@ class Code
       def self.function_documentation(scope)
         return INSTANCE_FUNCTIONS if scope == :instance
 
-        {}
+        CLASS_FUNCTIONS
       end
 
       DEFAULT_PORT = 587
@@ -31,6 +63,69 @@ class Code
       DEFAULT_DOMAIN = "localhost.localdomain"
       ALLOWED_PORTS = [465, 587].freeze
 
+      def self.call(**args)
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, []).to_code
+
+        case code_operator.to_s
+        when "encode"
+          sig(args) { MESSAGE_ARGUMENTS }
+          code_encode(code_arguments.code_first)
+        when "address"
+          sig(args) { String }
+          code_address(*code_arguments.raw)
+        else
+          super
+        end
+      end
+
+      def self.code_address(value)
+        text = value.to_s
+        raise Error, "smtp: invalid address" if text.match?(/[\r\n]/)
+
+        addresses = Mail::AddressList.new(text).addresses
+        raise Error, "smtp: expected one address" unless addresses.length == 1
+
+        address = addresses.first
+        unless address.local.present? && address.domain.present?
+          raise Error, "smtp: invalid address"
+        end
+
+        { email: address.address, name: address.display_name }.to_code
+      rescue Mail::Field::ParseError
+        raise Error, "smtp: invalid address"
+      end
+
+      def self.code_encode(message)
+        build_mail(message.to_code).encoded.to_code
+      end
+
+      def self.build_mail(message)
+        mail = Mail.new
+        mail.from = message.code_get("from").to_s
+        mail.to = message.code_get("to").to_s
+        mail.subject = message.code_get("subject").to_s
+        message_id = message.code_get("message_id").to_s
+        if message_id.match?(/[\r\n]/)
+          raise Error, "smtp: invalid message id"
+        end
+
+        mail.message_id = message_id if message_id.present?
+
+        text_part = Mail::Part.new
+        text_part.content_type = TEXT_CONTENT_TYPE
+        text_part.body = message.code_get("body_text").to_s.presence || message.code_get("body").to_s
+        mail.content_type = MULTIPART_CONTENT_TYPE
+        mail.add_part(text_part)
+        if message.code_get("body_html").to_s.present?
+          html_part = Mail::Part.new
+          html_part.content_type = HTML_CONTENT_TYPE
+          html_part.body = message.code_get("body_html").to_s
+          mail.add_part(html_part)
+        end
+        mail
+      end
+
       def call(**args)
         code_operator = args.fetch(:operator, nil).to_code
         code_arguments = args.fetch(:arguments, []).to_code
@@ -38,16 +133,7 @@ class Code
 
         case code_operator.to_s
         when "send"
-          sig(args) do
-            {
-              from: String.maybe,
-              to: String.maybe,
-              subject: String.maybe,
-              body: String.maybe,
-              body_text: String.maybe,
-              body_html: String.maybe
-            }
-          end
+          sig(args) { MESSAGE_ARGUMENTS }
 
           code_send(
             from: code_value.code_get("from"),
@@ -55,7 +141,8 @@ class Code
             subject: code_value.code_get("subject"),
             body: code_value.code_get("body"),
             body_text: code_value.code_get("body_text"),
-            body_html: code_value.code_get("body_html")
+            body_html: code_value.code_get("body_html"),
+            message_id: code_value.code_get("message_id")
           )
         else
           super
@@ -68,31 +155,12 @@ class Code
         subject: nil,
         body: nil,
         body_text: nil,
-        body_html: nil
+        body_html: nil,
+        message_id: nil
       )
-        code_from = from.to_code
-        code_to = to.to_code
-        code_subject = subject.to_code
-        code_body = body.to_code
-        code_body_text = body_text.to_code
-        code_body_html = body_html.to_code
-
-        mail = Mail.new
-        mail.from = code_from.to_s
-        mail.to = code_to.to_s
-        mail.subject = code_subject.to_s
-
-        text_part = Mail::Part.new
-        text_part.content_type = "text/plain; charset=UTF-8"
-        text_part.body = code_body_text.to_s.presence || code_body.to_s
-
-        html_part = Mail::Part.new
-        html_part.content_type = "text/html; charset=UTF-8"
-        html_part.body = code_body_html.to_s
-
-        mail.content_type = "multipart/alternative"
-        mail.add_part(text_part)
-        mail.add_part(html_part) if code_body_html.to_s.present?
+        mail = self.class.build_mail(
+          { from:, to:, subject:, body:, body_text:, body_html:, message_id: }.to_code
+        )
 
         address = code_get("address").to_s
         port = code_get("port").nothing? ? DEFAULT_PORT : code_get("port").to_i

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.2
 platform: ruby
 authors:
 - Dorian Marié