cloud_events 0.7.0 → 0.8.0

data/lib/cloud_events/json_format.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "base64"
 require "json"
 
 module CloudEvents
@@ -38,21 +37,21 @@ module CloudEvents
     # @raise [CloudEvents::SpecVersionError] if an unsupported specversion is
     #     found.
     #
-    def decode_event content: nil, content_type: nil, data_decoder: nil, **_other_kwargs
+    def decode_event(content: nil, content_type: nil, data_decoder: nil, **_other_kwargs)
       return nil unless content && content_type&.media_type == "application" && content_type&.subtype_format == "json"
       case content_type.subtype_base
       when "cloudevents"
-        event = decode_hash_structure ::JSON.parse(content), charset: charset_of(content), data_decoder: data_decoder
+        event = decode_hash_structure(::JSON.parse(content), charset: charset_of(content), data_decoder: data_decoder)
         { event: event }
       when "cloudevents-batch"
-        charset = charset_of content
+        charset = charset_of(content)
         batch = Array(::JSON.parse(content)).map do |structure|
-          decode_hash_structure structure, charset: charset, data_decoder: data_decoder
+          decode_hash_structure(structure, charset: charset, data_decoder: data_decoder)
         end
         { event_batch: batch }
       end
     rescue ::JSON::JSONError
-      raise FormatSyntaxError, "JSON syntax error"
+      raise(FormatSyntaxError, "JSON syntax error")
     end
 
     ##
@@ -78,25 +77,25 @@ module CloudEvents
     # @return [nil] if declining the request.
     # @raise [CloudEvents::FormatSyntaxError] if the JSON could not be parsed
     #
-    def encode_event event: nil, event_batch: nil, data_encoder: nil, sort: false, **_other_kwargs
+    def encode_event(event: nil, event_batch: nil, data_encoder: nil, sort: false, **_other_kwargs)
       if event && !event_batch
-        structure = encode_hash_structure event, data_encoder: data_encoder
-        structure = sort_keys structure if sort
+        structure = encode_hash_structure(event, data_encoder: data_encoder)
+        structure = sort_keys(structure) if sort
         subtype = "cloudevents"
       elsif event_batch && !event
         structure = event_batch.map do |elem|
-          structure_elem = encode_hash_structure elem, data_encoder: data_encoder
+          structure_elem = encode_hash_structure(elem, data_encoder: data_encoder)
           sort ? sort_keys(structure_elem) : structure_elem
         end
         subtype = "cloudevents-batch"
       else
         return nil
       end
-      content = ::JSON.dump structure
-      content_type = ContentType.new "application/#{subtype}+json; charset=#{charset_of content}"
+      content = ::JSON.dump(structure)
+      content_type = ContentType.new("application/#{subtype}+json; charset=#{charset_of(content)}")
       { content: content, content_type: content_type }
     rescue ::JSON::JSONError
-      raise FormatSyntaxError, "JSON syntax error"
+      raise(FormatSyntaxError, "JSON syntax error")
     end
 
     ##
@@ -120,17 +119,17 @@ module CloudEvents
     # @raise [CloudEvents::SpecVersionError] if an unsupported specversion is
     #     found.
     #
-    def decode_data spec_version: nil, content: nil, content_type: nil, **_other_kwargs
+    def decode_data(spec_version: nil, content: nil, content_type: nil, **_other_kwargs)
       return nil unless spec_version
       return nil unless content
-      return nil unless json_content_type? content_type
+      return nil unless json_content_type?(content_type)
       unless spec_version =~ /^0\.3|1(\.|$)/
-        raise SpecVersionError, "Unrecognized specversion: #{spec_version}"
+        raise(SpecVersionError, "Unrecognized specversion: #{spec_version}")
       end
-      data = ::JSON.parse content
+      data = ::JSON.parse(content)
       { data: data, content_type: content_type }
     rescue ::JSON::JSONError
-      raise FormatSyntaxError, "JSON syntax error"
+      raise(FormatSyntaxError, "JSON syntax error")
     end
 
     ##
@@ -155,15 +154,15 @@ module CloudEvents
     # @return [Hash] if accepting the request.
     # @return [nil] if declining the request.
     #
-    def encode_data spec_version: nil, data: UNSPECIFIED, content_type: nil, sort: false, **_other_kwargs
+    def encode_data(spec_version: nil, data: UNSPECIFIED, content_type: nil, sort: false, **_other_kwargs)
       return nil unless spec_version
       return nil if data == UNSPECIFIED
-      return nil unless json_content_type? content_type
+      return nil unless json_content_type?(content_type)
       unless spec_version =~ /^0\.3|1(\.|$)/
-        raise SpecVersionError, "Unrecognized specversion: #{spec_version}"
+        raise(SpecVersionError, "Unrecognized specversion: #{spec_version}")
       end
-      data = sort_keys data if sort
-      content = ::JSON.dump data
+      data = sort_keys(data) if sort
+      content = ::JSON.dump(data)
       { content: content, content_type: content_type }
     end
 
@@ -178,15 +177,15 @@ module CloudEvents
     #     non-JSON content types.
     # @return [CloudEvents::Event]
     #
-    def decode_hash_structure structure, charset: nil, data_decoder: nil
+    def decode_hash_structure(structure, charset: nil, data_decoder: nil)
       spec_version = structure["specversion"].to_s
       case spec_version
       when "0.3"
-        decode_hash_structure_v0 structure, charset
+        decode_hash_structure_v0(structure, charset)
       when /^1(\.|$)/
-        decode_hash_structure_v1 structure, charset, spec_version, data_decoder
+        decode_hash_structure_v1(structure, charset, spec_version, data_decoder)
       else
-        raise SpecVersionError, "Unrecognized specversion: #{spec_version}"
+        raise(SpecVersionError, "Unrecognized specversion: #{spec_version}")
       end
     end
 
@@ -199,33 +198,33 @@ module CloudEvents
     #     non-JSON content types.
     # @return [String] The hash structure.
     #
-    def encode_hash_structure event, data_encoder: nil
+    def encode_hash_structure(event, data_encoder: nil)
       case event
       when Event::V0
-        encode_hash_structure_v0 event
+        encode_hash_structure_v0(event)
       when Event::V1
-        encode_hash_structure_v1 event, data_encoder
+        encode_hash_structure_v1(event, data_encoder)
       else
-        raise SpecVersionError, "Unrecognized event type: #{event.class}"
+        raise(SpecVersionError, "Unrecognized event type: #{event.class}")
       end
     end
 
     private
 
-    def json_content_type? content_type
+    def json_content_type?(content_type)
       content_type&.subtype_base == "json" || content_type&.subtype_format == "json"
     end
 
-    def sort_keys obj
-      return obj unless obj.is_a? ::Hash
+    def sort_keys(obj)
+      return obj unless obj.is_a?(::Hash)
       result = {}
       obj.keys.sort.each do |key|
-        result[key] = sort_keys obj[key]
+        result[key] = sort_keys(obj[key])
       end
       result
     end
 
-    def charset_of str
+    def charset_of(str)
       encoding = str.encoding
       if encoding == ::Encoding::ASCII_8BIT
         "binary"
@@ -234,29 +233,29 @@ module CloudEvents
       end
     end
 
-    def decode_hash_structure_v0 structure, charset
-      unless structure.key? "datacontenttype"
+    def decode_hash_structure_v0(structure, charset)
+      unless structure.key?("datacontenttype")
         structure = structure.dup
         content_type = "application/json"
         content_type = "#{content_type}; charset=#{charset}" if charset
         structure["datacontenttype"] = content_type
       end
-      Event::V0.new attributes: structure
+      Event::V0.new(attributes: structure)
     end
 
-    def decode_hash_structure_v1 structure, charset, spec_version, data_decoder
+    def decode_hash_structure_v1(structure, charset, spec_version, data_decoder)
       unless structure.key?("data") || structure.key?("data_base64")
-        return Event::V1.new set_attributes: structure
+        return Event::V1.new(set_attributes: structure)
       end
       structure = structure.dup
-      content, content_type = retrieve_content_from_data_fields structure, charset
-      populate_data_fields_from_content structure, content, content_type, spec_version, data_decoder
-      Event::V1.new set_attributes: structure
+      content, content_type = retrieve_content_from_data_fields(structure, charset)
+      populate_data_fields_from_content(structure, content, content_type, spec_version, data_decoder)
+      Event::V1.new(set_attributes: structure)
     end
 
-    def retrieve_content_from_data_fields structure, charset
-      if structure.key? "data_base64"
-        content = ::Base64.decode64 structure.delete "data_base64"
+    def retrieve_content_from_data_fields(structure, charset)
+      if structure.key?("data_base64")
+        content = structure.delete("data_base64").unpack1("m")
         content_type = structure["datacontenttype"] || "application/octet-stream"
       else
         content = structure["data"]
@@ -266,60 +265,60 @@ module CloudEvents
       [content, ContentType.new(content_type)]
     end
 
-    def populate_data_fields_from_content structure, content, content_type, spec_version, data_decoder
-      if json_content_type? content_type
-        structure["data_encoded"] = ::JSON.dump content
+    def populate_data_fields_from_content(structure, content, content_type, spec_version, data_decoder)
+      if json_content_type?(content_type)
+        structure["data_encoded"] = ::JSON.dump(content)
         structure["data"] = content
       else
         structure["data_encoded"] = content = content.to_s
-        result = data_decoder&.decode_data spec_version: spec_version, content: content, content_type: content_type
+        result = data_decoder&.decode_data(spec_version: spec_version, content: content, content_type: content_type)
         if result
           structure["data"] = result[:data]
           content_type = result[:content_type]
         else
-          structure.delete "data"
+          structure.delete("data")
         end
       end
       structure["datacontenttype"] = content_type
     end
 
-    def encode_hash_structure_v0 event
+    def encode_hash_structure_v0(event)
       structure = event.to_h
       structure["datacontenttype"] ||= "application/json"
       structure
     end
 
-    def encode_hash_structure_v1 event, data_encoder
+    def encode_hash_structure_v1(event, data_encoder)
       structure = event.to_h
       return structure unless structure.key?("data") || structure.key?("data_encoded")
       content_type = event.data_content_type
       if content_type.nil? || json_content_type?(content_type)
-        encode_data_fields_for_json_content structure, event
+        encode_data_fields_for_json_content(structure, event)
       else
-        encode_data_fields_for_other_content structure, event, data_encoder
+        encode_data_fields_for_other_content(structure, event, data_encoder)
       end
       structure
     end
 
-    def encode_data_fields_for_json_content structure, event
-      structure["data"] = ::JSON.parse event.data unless event.data_decoded?
-      structure.delete "data_encoded"
+    def encode_data_fields_for_json_content(structure, event)
+      structure["data"] = ::JSON.parse(event.data) unless event.data_decoded?
+      structure.delete("data_encoded")
       structure["datacontenttype"] ||= "application/json"
     end
 
-    def encode_data_fields_for_other_content structure, event, data_encoder
-      data_encoded = structure.delete "data_encoded"
+    def encode_data_fields_for_other_content(structure, event, data_encoder)
+      data_encoded = structure.delete("data_encoded")
       unless data_encoded
-        result = data_encoder&.encode_data spec_version: event.spec_version,
+        result = data_encoder&.encode_data(spec_version: event.spec_version,
                                            data: event.data,
-                                           content_type: event.data_content_type
-        raise UnsupportedFormatError, "Unable to encode data of media type #{event.data_content_type}" unless result
+                                           content_type: event.data_content_type)
+        raise(UnsupportedFormatError, "Unable to encode data of media type #{event.data_content_type}") unless result
         data_encoded = result[:content]
         structure["datacontenttype"] = result[:content_type].to_s
       end
       if data_encoded.encoding == ::Encoding::ASCII_8BIT
-        structure["data_base64"] = ::Base64.encode64 data_encoded
-        structure.delete "data"
+        structure["data_base64"] = [data_encoded].pack("m0")
+        structure.delete("data")
       else
         structure["data"] = data_encoded
       end

data/lib/cloud_events/text_format.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "base64"
 require "json"
 
 module CloudEvents
@@ -31,9 +30,9 @@ module CloudEvents
     # @return [Hash] if accepting the request.
     # @return [nil] if declining the request.
     #
-    def decode_data content: nil, content_type: nil, **_other_kwargs
+    def decode_data(content: nil, content_type: nil, **_other_kwargs)
       return nil unless content
-      return nil unless text_content_type? content_type
+      return nil unless text_content_type?(content_type)
       { data: content.to_s, content_type: content_type }
     end
 
@@ -57,17 +56,17 @@ module CloudEvents
     # @return [Hash] if accepting the request.
     # @return [nil] if declining the request.
     #
-    def encode_data data: UNSPECIFIED, content_type: nil, **_other_kwargs
+    def encode_data(data: UNSPECIFIED, content_type: nil, **_other_kwargs)
       return nil if data == UNSPECIFIED
-      return nil unless text_content_type? content_type
+      return nil unless text_content_type?(content_type)
       { content: data.to_s, content_type: content_type }
     end
 
     private
 
-    def text_content_type? content_type
+    def text_content_type?(content_type)
       content_type&.media_type == "text" ||
-        content_type&.media_type == "application" && content_type&.subtype == "octet-stream"
+        (content_type&.media_type == "application" && content_type&.subtype == "octet-stream")
     end
   end
 end

data/lib/cloud_events/version.rb

@@ -5,5 +5,5 @@ module CloudEvents
   # Version of the Ruby CloudEvents SDK
   # @return [String]
   #
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cloud_events
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Daniel Azuma
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: The official Ruby implementation of the CloudEvents Specification. Provides
   data types for events, and HTTP/JSON bindings for marshalling and unmarshalling
@@ -21,8 +20,10 @@ extra_rdoc_files: []
 files:
 - ".yardopts"
 - CHANGELOG.md
-- LICENSE.md
+- CONTRIBUTING.md
+- MAINTAINERS.md
 - README.md
+- RELEASING.md
 - lib/cloud_events.rb
 - lib/cloud_events/content_type.rb
 - lib/cloud_events/errors.rb
@@ -41,11 +42,10 @@ homepage: https://github.com/cloudevents/sdk-ruby
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://cloudevents.github.io/sdk-ruby/v0.7.0/file.CHANGELOG.html
+  changelog_uri: https://cloudevents.github.io/sdk-ruby/v0.8.0/file.CHANGELOG.html
   source_code_uri: https://github.com/cloudevents/sdk-ruby
   bug_tracker_uri: https://github.com/cloudevents/sdk-ruby/issues
-  documentation_uri: https://cloudevents.github.io/sdk-ruby/v0.7.0
-post_install_message: 
+  documentation_uri: https://cloudevents.github.io/sdk-ruby/v0.8.0
 rdoc_options: []
 require_paths:
 - lib
@@ -53,15 +53,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby SDK for CloudEvents
 test_files: []

data/LICENSE.md

@@ -1,202 +0,0 @@
-
-                                  Apache License
-                            Version 2.0, January 2004
-                         http://www.apache.org/licenses/
-
-    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-    1. Definitions.
-
-       "License" shall mean the terms and conditions for use, reproduction,
-       and distribution as defined by Sections 1 through 9 of this document.
-
-       "Licensor" shall mean the copyright owner or entity authorized by
-       the copyright owner that is granting the License.
-
-       "Legal Entity" shall mean the union of the acting entity and all
-       other entities that control, are controlled by, or are under common
-       control with that entity. For the purposes of this definition,
-       "control" means (i) the power, direct or indirect, to cause the
-       direction or management of such entity, whether by contract or
-       otherwise, or (ii) ownership of fifty percent (50%) or more of the
-       outstanding shares, or (iii) beneficial ownership of such entity.
-
-       "You" (or "Your") shall mean an individual or Legal Entity
-       exercising permissions granted by this License.
-
-       "Source" form shall mean the preferred form for making modifications,
-       including but not limited to software source code, documentation
-       source, and configuration files.
-
-       "Object" form shall mean any form resulting from mechanical
-       transformation or translation of a Source form, including but
-       not limited to compiled object code, generated documentation,
-       and conversions to other media types.
-
-       "Work" shall mean the work of authorship, whether in Source or
-       Object form, made available under the License, as indicated by a
-       copyright notice that is included in or attached to the work
-       (an example is provided in the Appendix below).
-
-       "Derivative Works" shall mean any work, whether in Source or Object
-       form, that is based on (or derived from) the Work and for which the
-       editorial revisions, annotations, elaborations, or other modifications
-       represent, as a whole, an original work of authorship. For the purposes
-       of this License, Derivative Works shall not include works that remain
-       separable from, or merely link (or bind by name) to the interfaces of,
-       the Work and Derivative Works thereof.
-
-       "Contribution" shall mean any work of authorship, including
-       the original version of the Work and any modifications or additions
-       to that Work or Derivative Works thereof, that is intentionally
-       submitted to Licensor for inclusion in the Work by the copyright owner
-       or by an individual or Legal Entity authorized to submit on behalf of
-       the copyright owner. For the purposes of this definition, "submitted"
-       means any form of electronic, verbal, or written communication sent
-       to the Licensor or its representatives, including but not limited to
-       communication on electronic mailing lists, source code control systems,
-       and issue tracking systems that are managed by, or on behalf of, the
-       Licensor for the purpose of discussing and improving the Work, but
-       excluding communication that is conspicuously marked or otherwise
-       designated in writing by the copyright owner as "Not a Contribution."
-
-       "Contributor" shall mean Licensor and any individual or Legal Entity
-       on behalf of whom a Contribution has been received by Licensor and
-       subsequently incorporated within the Work.
-
-    2. Grant of Copyright License. Subject to the terms and conditions of
-       this License, each Contributor hereby grants to You a perpetual,
-       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-       copyright license to reproduce, prepare Derivative Works of,
-       publicly display, publicly perform, sublicense, and distribute the
-       Work and such Derivative Works in Source or Object form.
-
-    3. Grant of Patent License. Subject to the terms and conditions of
-       this License, each Contributor hereby grants to You a perpetual,
-       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-       (except as stated in this section) patent license to make, have made,
-       use, offer to sell, sell, import, and otherwise transfer the Work,
-       where such license applies only to those patent claims licensable
-       by such Contributor that are necessarily infringed by their
-       Contribution(s) alone or by combination of their Contribution(s)
-       with the Work to which such Contribution(s) was submitted. If You
-       institute patent litigation against any entity (including a
-       cross-claim or counterclaim in a lawsuit) alleging that the Work
-       or a Contribution incorporated within the Work constitutes direct
-       or contributory patent infringement, then any patent licenses
-       granted to You under this License for that Work shall terminate
-       as of the date such litigation is filed.
-
-    4. Redistribution. You may reproduce and distribute copies of the
-       Work or Derivative Works thereof in any medium, with or without
-       modifications, and in Source or Object form, provided that You
-       meet the following conditions:
-
-       (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-       (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-       (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-       (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-       You may add Your own copyright statement to Your modifications and
-       may provide additional or different license terms and conditions
-       for use, reproduction, or distribution of Your modifications, or
-       for any such Derivative Works as a whole, provided Your use,
-       reproduction, and distribution of the Work otherwise complies with
-       the conditions stated in this License.
-
-    5. Submission of Contributions. Unless You explicitly state otherwise,
-       any Contribution intentionally submitted for inclusion in the Work
-       by You to the Licensor shall be under the terms and conditions of
-       this License, without any additional terms or conditions.
-       Notwithstanding the above, nothing herein shall supersede or modify
-       the terms of any separate license agreement you may have executed
-       with Licensor regarding such Contributions.
-
-    6. Trademarks. This License does not grant permission to use the trade
-       names, trademarks, service marks, or product names of the Licensor,
-       except as required for reasonable and customary use in describing the
-       origin of the Work and reproducing the content of the NOTICE file.
-
-    7. Disclaimer of Warranty. Unless required by applicable law or
-       agreed to in writing, Licensor provides the Work (and each
-       Contributor provides its Contributions) on an "AS IS" BASIS,
-       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-       implied, including, without limitation, any warranties or conditions
-       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-       PARTICULAR PURPOSE. You are solely responsible for determining the
-       appropriateness of using or redistributing the Work and assume any
-       risks associated with Your exercise of permissions under this License.
-
-    8. Limitation of Liability. In no event and under no legal theory,
-       whether in tort (including negligence), contract, or otherwise,
-       unless required by applicable law (such as deliberate and grossly
-       negligent acts) or agreed to in writing, shall any Contributor be
-       liable to You for damages, including any direct, indirect, special,
-       incidental, or consequential damages of any character arising as a
-       result of this License or out of the use or inability to use the
-       Work (including but not limited to damages for loss of goodwill,
-       work stoppage, computer failure or malfunction, or any and all
-       other commercial damages or losses), even if such Contributor
-       has been advised of the possibility of such damages.
-
-    9. Accepting Warranty or Additional Liability. While redistributing
-       the Work or Derivative Works thereof, You may choose to offer,
-       and charge a fee for, acceptance of support, warranty, indemnity,
-       or other liability obligations and/or rights consistent with this
-       License. However, in accepting such obligations, You may act only
-       on Your own behalf and on Your sole responsibility, not on behalf
-       of any other Contributor, and only if You agree to indemnify,
-       defend, and hold each Contributor harmless for any liability
-       incurred by, or claims asserted against, such Contributor by reason
-       of your accepting any such warranty or additional liability.
-
-    END OF TERMS AND CONDITIONS
-
-    APPENDIX: How to apply the Apache License to your work.
-
-       To apply the Apache License to your work, attach the following
-       boilerplate notice, with the fields enclosed by brackets "[]"
-       replaced with your own identifying information. (Don't include
-       the brackets!)  The text should be enclosed in the appropriate
-       comment syntax for the file format. We also recommend that a
-       file or class name and description of purpose be included on the
-       same "printed page" as the copyright notice for easier
-       identification within third-party archives.
-
-    Copyright [yyyy] [name of copyright owner]
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.