cloud_events 0.7.0 → 0.8.0

data/lib/cloud_events/http_binding.rb

@@ -31,7 +31,7 @@ module CloudEvents
     def self.default
       @default ||= begin
         http_binding = new
-        http_binding.register_formatter JsonFormat.new, encoder_name: JSON_FORMAT
+        http_binding.register_formatter(JsonFormat.new, encoder_name: JSON_FORMAT)
         http_binding.default_encoder_name = JSON_FORMAT
         http_binding
       end
@@ -46,14 +46,14 @@ module CloudEvents
       end
       @event_encoders = {}
       @data_decoders = Format::Multi.new do |result|
-        result&.key?(:data) && result&.key?(:content_type) ? result : nil
+        result&.key?(:data) && result.key?(:content_type) ? result : nil
       end
       @data_encoders = Format::Multi.new do |result|
-        result&.key?(:content) && result&.key?(:content_type) ? result : nil
+        result&.key?(:content) && result.key?(:content_type) ? result : nil
       end
       text_format = TextFormat.new
-      @data_decoders.formats.replace [text_format, DefaultDataFormat]
-      @data_encoders.formats.replace [text_format, DefaultDataFormat]
+      @data_decoders.formats.replace([text_format, DefaultDataFormat])
+      @data_encoders.formats.replace([text_format, DefaultDataFormat])
 
       @default_encoder_name = nil
     end
@@ -71,18 +71,18 @@ module CloudEvents
     #     and will be removed in version 1.0. Use encoder_name instead.
     # @return [self]
     #
-    def register_formatter formatter, deprecated_name = nil, encoder_name: nil
+    def register_formatter(formatter, deprecated_name = nil, encoder_name: nil)
       encoder_name ||= deprecated_name
       encoder_name = encoder_name.to_s.strip.downcase if encoder_name
-      decode_event = formatter.respond_to? :decode_event
-      encode_event = encoder_name if formatter.respond_to? :encode_event
-      decode_data = formatter.respond_to? :decode_data
-      encode_data = formatter.respond_to? :encode_data
-      register_formatter_methods formatter,
+      decode_event = formatter.respond_to?(:decode_event)
+      encode_event = encoder_name if formatter.respond_to?(:encode_event)
+      decode_data = formatter.respond_to?(:decode_data)
+      encode_data = formatter.respond_to?(:encode_data)
+      register_formatter_methods(formatter,
                                  decode_event: decode_event,
                                  encode_event: encode_event,
                                  decode_data: decode_data,
-                                 encode_data: encode_data
+                                 encode_data: encode_data)
       self
     end
 
@@ -102,20 +102,20 @@ module CloudEvents
     #     {CloudEvents::Format#encode_data} method.
     # @return [self]
     #
-    def register_formatter_methods formatter,
+    def register_formatter_methods(formatter,
                                    decode_event: false,
                                    encode_event: nil,
                                    decode_data: false,
-                                   encode_data: false
-      @event_decoders.formats.unshift formatter if decode_event
+                                   encode_data: false)
+      @event_decoders.formats.unshift(formatter) if decode_event
       if encode_event
         encoders = @event_encoders[encode_event] ||= Format::Multi.new do |result|
-          result&.key?(:content) && result&.key?(:content_type) ? result : nil
+          result&.key?(:content) && result.key?(:content_type) ? result : nil
         end
-        encoders.formats.unshift formatter
+        encoders.formats.unshift(formatter)
       end
-      @data_decoders.formats.unshift formatter if decode_data
-      @data_encoders.formats.unshift formatter if encode_data
+      @data_decoders.formats.unshift(formatter) if decode_data
+      @data_encoders.formats.unshift(formatter) if encode_data
       self
     end
 
@@ -136,10 +136,10 @@ module CloudEvents
     # @param env [Hash] The Rack environment.
     # @return [boolean] Whether the request is likely a CloudEvent.
     #
-    def probable_event? env
-      return false if ILLEGAL_METHODS.include? env["REQUEST_METHOD"]
+    def probable_event?(env)
+      return false if ILLEGAL_METHODS.include?(env["REQUEST_METHOD"])
       return true if env["HTTP_CE_SPECVERSION"]
-      content_type = ContentType.new env["CONTENT_TYPE"].to_s
+      content_type = ContentType.new(env["CONTENT_TYPE"].to_s)
       content_type.media_type == "application" &&
         ["cloudevents", "cloudevents-batch"].include?(content_type.subtype_base)
     end
@@ -166,17 +166,17 @@ module CloudEvents
     # @raise [CloudEvents::CloudEventsError] if an event could not be decoded
     #     from the request.
     #
-    def decode_event env, allow_opaque: false, **format_args
+    def decode_event(env, allow_opaque: false, **format_args)
       request_method = env["REQUEST_METHOD"]
-      raise NotCloudEventError, "Request method is #{request_method}" if ILLEGAL_METHODS.include? request_method
+      raise(NotCloudEventError, "Request method is #{request_method}") if ILLEGAL_METHODS.include?(request_method)
       content_type_string = env["CONTENT_TYPE"]
-      content_type = ContentType.new content_type_string if content_type_string
-      content = read_with_charset env["rack.input"], content_type&.charset
+      content_type = ContentType.new(content_type_string) if content_type_string
+      content = read_with_charset(env["rack.input"], content_type&.charset)
       result = decode_binary_content(content, content_type, env, false, **format_args) ||
                decode_structured_content(content, content_type, allow_opaque, **format_args)
       if result.nil?
         content_type_string = content_type_string ? content_type_string.inspect : "not present"
-        raise NotCloudEventError, "Content-Type is #{content_type_string}, and CE-SpecVersion is not present"
+        raise(NotCloudEventError, "Content-Type is #{content_type_string}, and CE-SpecVersion is not present")
       end
       result
     end
@@ -204,24 +204,24 @@ module CloudEvents
     # @param format_args [keywords] Extra args to pass to the formatter.
     # @return [Array(headers,String)]
     #
-    def encode_event event, structured_format: false, **format_args
-      if event.is_a? Event::Opaque
+    def encode_event(event, structured_format: false, **format_args)
+      if event.is_a?(Event::Opaque)
         [{ "Content-Type" => event.content_type.to_s }, event.content]
       elsif !structured_format
-        if event.is_a? ::Array
-          raise ::ArgumentError, "Encoding a batch requires structured_format"
+        if event.is_a?(::Array)
+          raise(::ArgumentError, "Encoding a batch requires structured_format")
         end
-        encode_binary_content event, legacy_data_encode: false, **format_args
+        encode_binary_content(event, legacy_data_encode: false, **format_args)
       else
         structured_format = default_encoder_name if structured_format == true
-        raise ::ArgumentError, "Format name not specified, and no default is set" unless structured_format
+        raise(::ArgumentError, "Format name not specified, and no default is set") unless structured_format
         case event
         when ::Array
-          encode_batched_content event, structured_format, **format_args
+          encode_batched_content(event, structured_format, **format_args)
         when Event
-          encode_structured_content event, structured_format, **format_args
+          encode_structured_content(event, structured_format, **format_args)
         else
-          raise ::ArgumentError, "Unknown event type: #{event.class}"
+          raise(::ArgumentError, "Unknown event type: #{event.class}")
         end
       end
     end
@@ -243,10 +243,10 @@ module CloudEvents
     # @raise [CloudEvents::CloudEventsError] if the request appears to be a
     #     CloudEvent but decoding failed.
     #
-    def decode_rack_env env, **format_args
+    def decode_rack_env(env, **format_args)
       content_type_string = env["CONTENT_TYPE"]
-      content_type = ContentType.new content_type_string if content_type_string
-      content = read_with_charset env["rack.input"], content_type&.charset
+      content_type = ContentType.new(content_type_string) if content_type_string
+      content = read_with_charset(env["rack.input"], content_type&.charset)
       env["rack.input"].rewind rescue nil
       decode_binary_content(content, content_type, env, true, **format_args) ||
         decode_structured_content(content, content_type, false, **format_args)
@@ -262,12 +262,12 @@ module CloudEvents
     # @param format_args [keywords] Extra args to pass to the formatter.
     # @return [Array(headers,String)]
     #
-    def encode_structured_content event, format_name, **format_args
-      result = @event_encoders[format_name]&.encode_event event: event,
+    def encode_structured_content(event, format_name, **format_args)
+      result = @event_encoders[format_name]&.encode_event(event: event,
                                                           data_encoder: @data_encoders,
-                                                          **format_args
+                                                          **format_args)
       return [{ "Content-Type" => result[:content_type].to_s }, result[:content]] if result
-      raise ::ArgumentError, "Unknown format name: #{format_name.inspect}"
+      raise(::ArgumentError, "Unknown format name: #{format_name.inspect}")
     end
 
     ##
@@ -280,12 +280,12 @@ module CloudEvents
     # @param format_args [keywords] Extra args to pass to the formatter.
     # @return [Array(headers,String)]
     #
-    def encode_batched_content event_batch, format_name, **format_args
-      result = @event_encoders[format_name]&.encode_event event_batch: event_batch,
+    def encode_batched_content(event_batch, format_name, **format_args)
+      result = @event_encoders[format_name]&.encode_event(event_batch: event_batch,
                                                           data_encoder: @data_encoders,
-                                                          **format_args
+                                                          **format_args)
       return [{ "Content-Type" => result[:content_type].to_s }, result[:content]] if result
-      raise ::ArgumentError, "Unknown format name: #{format_name.inspect}"
+      raise(::ArgumentError, "Unknown format name: #{format_name.inspect}")
     end
 
     ##
@@ -297,18 +297,18 @@ module CloudEvents
     # @param format_args [keywords] Extra args to pass to the formatter.
     # @return [Array(headers,String)]
     #
-    def encode_binary_content event, legacy_data_encode: true, **format_args
+    def encode_binary_content(event, legacy_data_encode: true, **format_args)
       headers = {}
       event.to_h.each do |key, value|
-        unless ["data", "data_encoded", "datacontenttype"].include? key
-          headers["CE-#{key}"] = percent_encode value
+        unless ["data", "data_encoded", "datacontenttype"].include?(key)
+          headers["CE-#{key}"] = percent_encode(value)
         end
       end
       body, content_type =
         if legacy_data_encode || event.spec_version.start_with?("0.")
-          legacy_extract_event_data event
+          legacy_extract_event_data(event)
         else
-          normal_extract_event_data event, format_args
+          normal_extract_event_data(event, format_args)
         end
       headers["Content-Type"] = content_type.to_s if content_type
       [headers, body]
@@ -323,10 +323,10 @@ module CloudEvents
     #     cycle of percent-encoding.
     # @return [String] Resulting decoded string in UTF-8.
     #
-    def percent_decode str
+    def percent_decode(str)
       str = str.gsub(/"((?:[^"\\]|\\.)*)"/) { ::Regexp.last_match(1).gsub(/\\(.)/, '\1') }
-      decoded_str = str.gsub(/%[0-9a-fA-F]{2}/) { |m| [m[1..-1].to_i(16)].pack "C" }
-      decoded_str.force_encoding ::Encoding::UTF_8
+      decoded_str = str.gsub(/%[0-9a-fA-F]{2}/) { |m| [m[1..].to_i(16)].pack("C") }
+      decoded_str.force_encoding(::Encoding::UTF_8)
     end
 
     ##
@@ -340,9 +340,9 @@ module CloudEvents
     #     in UTF-8.
     # @return [String] Resulting encoded string in ASCII.
     #
-    def percent_encode str
+    def percent_encode(str)
       arr = []
-      utf_str = str.to_s.encode ::Encoding::UTF_8
+      utf_str = str.to_s.encode(::Encoding::UTF_8)
       utf_str.each_byte do |byte|
         if byte >= 33 && byte <= 126 && byte != 34 && byte != 37
           arr << byte
@@ -354,31 +354,31 @@ module CloudEvents
           arr << 37 << hi << lo
         end
       end
-      arr.pack "C*"
+      arr.pack("C*")
     end
 
     private
 
-    def add_named_formatter collection, formatter, name
+    def add_named_formatter(collection, formatter, name)
       return unless name
       formatters = collection[name] ||= []
-      formatters.unshift formatter unless formatters.include? formatter
+      formatters.unshift(formatter) unless formatters.include?(formatter)
     end
 
     ##
     # Decode a single event from the given request body and content type in
     # structured mode.
     #
-    def decode_structured_content content, content_type, allow_opaque, **format_args
-      result = @event_decoders.decode_event content: content,
+    def decode_structured_content(content, content_type, allow_opaque, **format_args)
+      result = @event_decoders.decode_event(content: content,
                                             content_type: content_type,
                                             data_decoder: @data_decoders,
-                                            **format_args
+                                            **format_args)
       return result[:event] || result[:event_batch] if result
       if content_type&.media_type == "application" &&
          ["cloudevents", "cloudevents-batch"].include?(content_type.subtype_base)
-        return Event::Opaque.new content, content_type if allow_opaque
-        raise UnsupportedFormatError, "Unknown cloudevents content type: #{content_type}"
+        return Event::Opaque.new(content, content_type) if allow_opaque
+        raise(UnsupportedFormatError, "Unknown cloudevents content type: #{content_type}")
       end
       nil
     end
@@ -389,33 +389,33 @@ module CloudEvents
     # TODO: legacy_data_decode is deprecated and can be removed when
     # decode_rack_env is removed.
     #
-    def decode_binary_content content, content_type, env, legacy_data_decode, **format_args
+    def decode_binary_content(content, content_type, env, legacy_data_decode, **format_args)
       spec_version = env["HTTP_CE_SPECVERSION"]
       return nil unless spec_version
       unless spec_version =~ /^0\.3|1(\.|$)/
-        raise SpecVersionError, "Unrecognized specversion: #{spec_version}"
+        raise(SpecVersionError, "Unrecognized specversion: #{spec_version}")
       end
       attributes = { "spec_version" => spec_version }
       if legacy_data_decode || spec_version.start_with?("0.")
-        legacy_populate_data_attributes attributes, content, content_type
+        legacy_populate_data_attributes(attributes, content, content_type)
       else
-        normal_populate_data_attributes attributes, content, content_type, spec_version, format_args
+        normal_populate_data_attributes(attributes, content, content_type, spec_version, format_args)
       end
-      populate_attributes_from_env attributes, env
-      Event.create spec_version: spec_version, set_attributes: attributes
+      populate_attributes_from_env(attributes, env)
+      Event.create(spec_version: spec_version, set_attributes: attributes)
     end
 
-    def legacy_populate_data_attributes attributes, content, content_type
+    def legacy_populate_data_attributes(attributes, content, content_type)
       attributes["data"] = content
       attributes["data_content_type"] = content_type if content_type
     end
 
-    def normal_populate_data_attributes attributes, content, content_type, spec_version, format_args
+    def normal_populate_data_attributes(attributes, content, content_type, spec_version, format_args)
       attributes["data_encoded"] = content
-      result = @data_decoders.decode_data spec_version: spec_version,
+      result = @data_decoders.decode_data(spec_version: spec_version,
                                           content: content,
                                           content_type: content_type,
-                                          **format_args
+                                          **format_args)
       if result
         attributes["data"] = result[:data]
         content_type = result[:content_type]
@@ -423,17 +423,17 @@ module CloudEvents
       attributes["data_content_type"] = content_type if content_type
     end
 
-    def populate_attributes_from_env attributes, env
+    def populate_attributes_from_env(attributes, env)
       omit_names = ["specversion", "spec_version", "data", "datacontenttype", "data_content_type"]
       env.each do |key, value|
-        match = /^HTTP_CE_(\w+)$/.match key
+        match = /^HTTP_CE_(\w+)$/.match(key)
         next unless match
         attr_name = match[1].downcase
-        attributes[attr_name] = percent_decode value unless omit_names.include? attr_name
+        attributes[attr_name] = percent_decode(value) unless omit_names.include?(attr_name)
       end
     end
 
-    def legacy_extract_event_data event
+    def legacy_extract_event_data(event)
       body = event.data
       content_type = event.data_content_type&.to_s
       case body
@@ -446,31 +446,31 @@ module CloudEvents
       end
     end
 
-    def normal_extract_event_data event, format_args
+    def normal_extract_event_data(event, format_args)
       body = event.data_encoded
       if body
         [body, event.data_content_type]
       elsif event.data?
-        result = @data_encoders.encode_data spec_version: event.spec_version,
+        result = @data_encoders.encode_data(spec_version: event.spec_version,
                                             data: event.data,
                                             content_type: event.data_content_type,
-                                            **format_args
-        raise UnsupportedFormatError, "Could not encode unknown content-type: #{content_type}" unless result
+                                            **format_args)
+        raise(UnsupportedFormatError, "Could not encode unknown content-type: #{content_type}") unless result
         [result[:content], result[:content_type]]
       else
         ["", nil]
       end
     end
 
-    def read_with_charset io, charset
+    def read_with_charset(io, charset)
       return nil if io.nil?
       str = io.read
       if charset
         begin
-          str.force_encoding charset
+          str.force_encoding(charset)
         rescue ::ArgumentError
           # Use binary for now if the charset is unrecognized
-          str.force_encoding ::Encoding::ASCII_8BIT
+          str.force_encoding(::Encoding::ASCII_8BIT)
         end
       end
       str
@@ -479,13 +479,13 @@ module CloudEvents
     # @private
     module DefaultDataFormat
       # @private
-      def self.decode_data content: nil, content_type: nil, **_extra_kwargs
+      def self.decode_data(content: nil, content_type: nil, **_extra_kwargs)
         return nil unless content_type.nil?
         { data: content, content_type: nil }
       end
 
       # @private
-      def self.encode_data data: nil, content_type: nil, **_extra_kwargs
+      def self.encode_data(data: nil, content_type: nil, **_extra_kwargs)
         return nil unless content_type.nil?
         { content: data.to_s, content_type: nil }
       end