functions_framework 0.7.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6d562086a839aaf78661b9417d3b931df10c74c98cb07b1710d40d6294b0490
-  data.tar.gz: fd070c121ce3e0c1bab7f1a738178a37c72c5d25c7726d3f3540e687d01bbe25
+  metadata.gz: feaa072a9d05a5a0308e4721d338aea1d5bdcb65d257f74210073518d3f21735
+  data.tar.gz: ef5d554a4ebf4dcb5e5d00b88f17ac36bd151d3b061038a35a26ed520dcd02b7
 SHA512:
-  metadata.gz: 478554bfc8b8bafb2efd5bb880b8e053e2442a878bcd1363a4c6ddeab77a811b49530b84f467009b01f2299b70105f17a8a9840d9b35ebbec94359ca14d7114c
-  data.tar.gz: 6873da52a257f542cb782fde59ba7da7f96042f4b69eaf470ea23d81cdb8479e8ff2791a6fbd0fd36ec166039f9718b7ce1b14632c690b44bea2833e280835b5
+  metadata.gz: 699655e4efcd96b4fa46ccf2017f38d76848b2827115909b599bd722d2eb0d447da1fb3bc0323f825bf0b69024f1a947eaf969e95b205d90e6393babe2b8c15e
+  data.tar.gz: 297c2eda593a1b995c233b7ff89d92e11c7921322bceeb14eac71eb351bf04d0956e6c0de18e91137884ace3fc6f0a4422c2e3b79d7598fdc0ab567f93bfe638

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+### v1.0.0 / 2021-07-07
+
+* Bumped the version to 1.0.
+* Removed the "preview" notices for Google Cloud Functions since the Ruby runtime is now GA.
+
+### v0.11.0 / 2021-06-28
+
+* UPDATED: Update CloudEvents dependency to 0.5 to get fixes for JSON formatting cases
+* FIXED: Updated Pub/Sub and Firebase event conversion logic to better align to Eventarc
+
+### v0.10.0 / 2021-06-01
+
+* ADDED: Support raw pubsub events sent by the pubsub emulator
+* FIXED: Set proper response content-type charset when a function returns a string (plain text) or hash (JSON)
+* FIXED: Properly handle conversion of non-ascii characters in legacy event strings
+
+### v0.9.0 / 2021-03-18
+
+* BREAKING CHANGE: Servers are configured as single-threaded in production by default, matching the current behavior of Google Cloud Functions.
+* FIXED: Fixed conversion of Firebase events to CloudEvents to conform to the specs used by Cloud Functions and Cloud Run.
+* FIXED: Fixed an error when reading a global set to a Minitest::Mock. This will make it easier to write tests that use mocks for global resources.
+
+### v0.8.0 / 2021-03-02
+
+* ADDED: Support for lazily-initialized globals
+
 ### v0.7.1 / 2021-01-26
 
 * DOCS: Fixed several errors in the writing-functions doc samples

data/README.md

@@ -4,7 +4,7 @@ An open source framework for writing lightweight, portable Ruby functions that
 run in a serverless environment. Functions written to this Framework will run
 in many different environments, including:
 
- *  [Google Cloud Functions](https://cloud.google.com/functions) *(public preview)*
+ *  [Google Cloud Functions](https://cloud.google.com/functions)
  *  [Google Cloud Run](https://cloud.google.com/run)
  *  Any other [Knative](https://github.com/knative)-based environment
  *  Your local development machine
@@ -60,7 +60,7 @@ Create a `Gemfile` listing the Functions Framework as a dependency:
 ```ruby
 # Gemfile
 source "https://rubygems.org"
-gem "functions_framework", "~> 0.7"
+gem "functions_framework", "~> 1.0"
 ```
 
 Create a file called `app.rb` and include the following code. This defines a

data/docs/overview.md

@@ -8,7 +8,7 @@ The Functions Framework is an open source framework for writing lightweight,
 portable Ruby functions that run in a serverless environment. Functions written
 to this Framework will run in many different environments, including:
 
- *  [Google Cloud Functions](https://cloud.google.com/functions) *(public preview)*
+ *  [Google Cloud Functions](https://cloud.google.com/functions)
  *  [Google Cloud Run](https://cloud.google.com/run)
  *  Any other [Knative](https://github.com/knative)-based environment
  *  Your local development machine
@@ -64,7 +64,7 @@ Create a `Gemfile` listing the Functions Framework as a dependency:
 ```ruby
 # Gemfile
 source "https://rubygems.org"
-gem "functions_framework", "~> 0.7"
+gem "functions_framework", "~> 1.0"
 ```
 
 Create a file called `app.rb` and include the following code. This defines a

data/docs/writing-functions.md

@@ -111,7 +111,7 @@ dependency on Sinatra in your `Gemfile`:
 
 ```ruby
 source "https://rubygems.org"
-gem "functions_framework", "~> 0.7"
+gem "functions_framework", "~> 1.0"
 gem "sinatra", "~> 2.0"
 ```
 
@@ -152,7 +152,7 @@ information about it:
 require "functions_framework"
 
 FunctionsFramework.cloud_event "hello" do |event|
-  FunctionsFramework.logger.info "I received an event of type #{event.type}!"
+  logger.info "I received an event of type #{event.type}!"
 end
 ```
 
@@ -248,10 +248,10 @@ FunctionsFramework.http "hello" do |request|
 end
 ```
 
-Startup tasks are run once per Ruby instance, before the framework starts
-receiving requests and executing functions. You can define multiple startup
-tasks, and they will run in order, and are guaranteed to complete before any
-function is executed.
+Startup tasks are run once per Ruby instance during cold start -- that is,
+after the Ruby VM boots up but before the framework starts receiving requests
+and executing functions. You can define multiple startup tasks, and they will
+run in order, and are guaranteed to complete before any function is executed.
 
 The block is optionally passed the {FunctionsFramework::Function} representing
 the function that will be run. You code can, for example, perform different
@@ -286,6 +286,11 @@ end
 # ...
 ```
 
+Because startup tasks run during cold start, they could have an impact on your
+function's startup latency. To mitigate this issue, it is possible to run parts
+of your initialization lazily, as described below in the section below on
+[lazy initialization](#Lazy_initialization).
+
 ### The execution context and global data
 
 When your function block executes, the _object context_ (i.e. `self`) is set to
@@ -331,8 +336,9 @@ resources, as described below.
 Using the global data mechanism is generally preferred over actual Ruby global
 variables, because the Functions Framework can help you avoid concurrent edits.
 Additionally, the framework will isolate the sets of global data associated
-with different sets of functions, which lets you test functions in isolation
-without the tests interfering with one another by writing to global variables.
+with different sets of functions, which lets you run functions in isolation
+during unit tests. If you are testing multiple functions, they will not
+interfere with each other as they might if they used global variables.
 
 ### Sharing resources
 
@@ -345,10 +351,10 @@ re-establishing it for every function invocation.
 
 The best practice for sharing a resource across function invocations is to
 initialize it in a {FunctionsFramework.on_startup} block, and reference it from
-global shared data. (As discussed above, prefer to initialize shared resources
-in a startup task rather than at the top level of a Ruby file, and prefer using
-the Functions Framework's global data mechanism rather than Ruby's global
-variables.)
+global shared data. (As discussed above, the best practice is to initialize
+shared resources in a startup task rather than at the top level of a Ruby file,
+and to use the Functions Framework's global data mechanism rather than Ruby's
+global variables.)
 
 Here is a simple example:
 
@@ -383,6 +389,48 @@ may perform CPU throttling, and therefore there may not be an opportunity for
 cleanup tasks to run. (For example, you could register a `Kernel.at_exit` task,
 but the Ruby VM may still terminate without calling it.)
 
+### Lazy initialization
+
+Because startup tasks run during cold start, they could have an impact on your
+function's startup latency. You can mitigate this by initializing some globals
+_lazily_. When setting a global, instead of computing and setting the value
+directly (e.g. constructing a shared API client object directly), you can
+provide a block that describes how to construct it on demand.
+
+Here is an example using the storage client we saw above.
+
+```ruby
+require "functions_framework"
+
+# This startup block describes _how_ to initialize a shared client, but
+# does not construct it immediately.
+FunctionsFramework.on_startup do
+  require "google/cloud/storage"
+  set_global :storage_client do
+    Google::Cloud::Storage.new
+  end
+end
+
+# The first time this function is invoked, it will call the above block
+# to construct the storage client. Subsequent invocations will not need
+# to construct it again, but will reuse the same shared object.
+FunctionsFramework.http "storage_example" do |request|
+  bucket = global(:storage_client).bucket "my-bucket"
+  file = bucket.file "path/to/my-file.txt"
+  file.download.to_s
+end
+```
+
+The block will not be called until a function actually attempts to access the
+global. From that point, subsequent accesses of the global will return that
+same shared value; the block will be called at most once. This is true even if
+multiple functions are run concurrently in different threads.
+
+Lazy initialization is particularly useful if you define several different
+functions that may use different sets of shared resources. Instead of
+initializing all resources eagerly up front, you could initialize them lazily
+and run only the code needed by the function that is actually invoked.
+
 ## Structuring a project
 
 A Functions Framework based "project" or "application" is a typical Ruby
@@ -422,7 +470,7 @@ Following is a typical layout for a Functions Framework based project.
 ```ruby
 # Gemfile
 source "https://rubygems.org"
-gem "functions_framework", "~> 0.7"
+gem "functions_framework", "~> 1.0"
 ```
 
 ```ruby

data/lib/functions_framework/cli.rb

@@ -74,7 +74,7 @@ module FunctionsFramework
     # @param argv [Array<String>]
     # @return [self]
     #
-    def parse_args argv # rubocop:disable Metrics/MethodLength
+    def parse_args argv # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       @option_parser = ::OptionParser.new do |op| # rubocop:disable Metrics/BlockLength
         op.on "-t", "--target TARGET",
               "Set the name of the function to execute (defaults to #{DEFAULT_TARGET})" do |val|

data/lib/functions_framework/function.rb

@@ -164,6 +164,28 @@ module FunctionsFramework
       callable.call(*args)
     end
 
+    ##
+    # A lazy evaluator for a global
+    # @private
+    #
+    class LazyGlobal
+      def initialize block
+        @block = block
+        @value = nil
+        @mutex = ::Mutex.new
+      end
+
+      def value
+        @mutex.synchronize do
+          if @block
+            @value = @block.call
+            @block = nil
+          end
+          @value
+        end
+      end
+    end
+
     ##
     # A base class for a callable object that provides calling context.
     #
@@ -196,7 +218,9 @@ module FunctionsFramework
       # @return [Object]
       #
       def global key
-        @__globals[key]
+        value = @__globals[key]
+        value = value.value if LazyGlobal === value
+        value
       end
 
       ##
@@ -204,11 +228,35 @@ module FunctionsFramework
       # are frozen when the server starts, so this call will raise an exception
       # if called from a normal function.
       #
-      # @param key [Symbol,String]
-      # @param value [Object]
+      # You can set a global to a final value, or you can provide a block that
+      # lazily computes the global the first time it is requested.
+      #
+      # @overload set_global(key, value)
+      #   Set the given global to the given value. For example:
+      #
+      #       set_global(:project_id, "my-project-id")
+      #
+      #   @param key [Symbol,String]
+      #   @param value [Object]
+      #   @return [self]
+      #
+      # @overload set_global(key, &block)
+      #   Call the given block to compute the global's value only when the
+      #   value is actually requested. This block will be called at most once,
+      #   and its result reused for subsequent calls. For example:
+      #
+      #       set_global(:connection_pool) do
+      #         ExpensiveConnectionPool.new
+      #       end
+      #
+      #   @param key [Symbol,String]
+      #   @param block [Proc] A block that lazily computes a value
+      #   @yieldreturn [Object] The value
+      #   @return [self]
       #
-      def set_global key, value
-        @__globals[key] = value
+      def set_global key, value = nil, &block
+        @__globals[key] = block ? LazyGlobal.new(block) : value
+        self
       end
 
       ##

data/lib/functions_framework/legacy_event_converter.rb

@@ -27,20 +27,21 @@ module FunctionsFramework
     # @return [nil] if the event format was not recognized.
     #
     def decode_rack_env env
-      content_type = ::CloudEvents::ContentType.new env["CONTENT_TYPE"]
+      content_type = ::CloudEvents::ContentType.new env["CONTENT_TYPE"], default_charset: "utf-8"
       return nil unless content_type.media_type == "application" && content_type.subtype_base == "json"
       input = read_input_json env["rack.input"], content_type.charset
       return nil unless input
+      input = convert_raw_pubsub_event input, env if raw_pubsub_payload? input
       context = normalized_context input
       return nil unless context
-      construct_cloud_event context, input["data"], content_type.charset
+      construct_cloud_event context, input["data"]
     end
 
     private
 
     def read_input_json input, charset
       input = input.read if input.respond_to? :read
-      input = input.encode charset if charset
+      input.force_encoding charset if charset
       content = ::JSON.parse input
       content = nil unless content.is_a? ::Hash
       content
@@ -48,15 +49,50 @@ module FunctionsFramework
       nil
     end
 
+    def raw_pubsub_payload? input
+      return false if input.include?("context") || !input.include?("subscription")
+      message = input["message"]
+      message.is_a?(::Hash) && message.include?("data") && message.include?("messageId")
+    end
+
+    def convert_raw_pubsub_event input, env
+      message = input["message"]
+      path = "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+      path_match = %r{projects/[^/?]+/topics/[^/?]+}.match path
+      topic = path_match ? path_match[0] : "UNKNOWN_PUBSUB_TOPIC"
+      timestamp = message["publishTime"] || ::Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ")
+      {
+        "context" => {
+          "eventId" => message["messageId"],
+          "timestamp" => timestamp,
+          "eventType" => "google.pubsub.topic.publish",
+          "resource" => {
+            "service" => "pubsub.googleapis.com",
+            "type" => "type.googleapis.com/google.pubsub.v1.PubsubMessage",
+            "name" => topic
+          }
+        },
+        "data" => {
+          "@type" => "type.googleapis.com/google.pubsub.v1.PubsubMessage",
+          "data" => message["data"],
+          "attributes" => message["attributes"]
+        }
+      }
+    end
+
     def normalized_context input
-      raw_context = input["context"]
-      id = raw_context&.[]("eventId") || input["eventId"]
-      timestamp = raw_context&.[]("timestamp") || input["timestamp"]
-      type = raw_context&.[]("eventType") || input["eventType"]
-      service, resource = analyze_resource raw_context&.[]("resource") || input["resource"]
+      id = normalized_context_field input, "eventId"
+      timestamp = normalized_context_field input, "timestamp"
+      type = normalized_context_field input, "eventType"
+      domain = normalized_context_field input, "domain"
+      service, resource = analyze_resource normalized_context_field input, "resource"
       service ||= service_from_type type
       return nil unless id && timestamp && type && service && resource
-      { id: id, timestamp: timestamp, type: type, service: service, resource: resource }
+      { id: id, timestamp: timestamp, type: type, service: service, resource: resource, domain: domain }
+    end
+
+    def normalized_context_field input, field
+      input["context"]&.[](field) || input[field]
     end
 
     def analyze_resource raw_resource
@@ -78,37 +114,66 @@ module FunctionsFramework
       nil
     end
 
-    def construct_cloud_event context, data, charset
-      source, subject = convert_source context[:service], context[:resource]
+    def construct_cloud_event context, data
+      source, subject = convert_source context[:service], context[:resource], context[:domain]
       type = LEGACY_TYPE_TO_CE_TYPE[context[:type]]
       return nil unless type && source
-      ce_data = convert_data context[:service], data
-      content_type = "application/json; charset=#{charset}"
+      ce_data, data_subject = convert_data context, data
+      content_type = "application/json"
       ::CloudEvents::Event.new id:                context[:id],
                                source:            source,
                                type:              type,
                                spec_version:      "1.0",
                                data_content_type: content_type,
                                data:              ce_data,
-                               subject:           subject,
+                               subject:           subject || data_subject,
                                time:              context[:timestamp]
     end
 
-    def convert_source service, resource
-      if service == "storage.googleapis.com"
-        match = %r{^(projects/[^/]+/buckets/[^/]+)/([^#]+)(?:#.*)?$}.match resource
-        return [nil, nil] unless match
-        ["//#{service}/#{match[1]}", match[2]]
+    def convert_source service, resource, domain
+      return ["//#{service}/#{resource}", nil] unless CE_SERVICE_TO_RESOURCE_RE.key? service
+
+      match = CE_SERVICE_TO_RESOURCE_RE[service].match resource
+      return [nil, nil] unless match
+      resource_fragment = match[1]
+      subject = match[2]
+
+      if service == "firebasedatabase.googleapis.com"
+        location =
+          case domain
+          when "firebaseio.com"
+            "us-central1"
+          when /^([\w-]+)\./
+            Regexp.last_match[1]
+          else
+            return [nil, nil]
+          end
+        ["//#{service}/projects/_/locations/#{location}/#{resource_fragment}", subject]
       else
-        ["//#{service}/#{resource}", nil]
+        ["//#{service}/#{resource_fragment}", subject]
       end
     end
 
-    def convert_data service, data
-      if service == "pubsub.googleapis.com"
-        { "message" => data, "subscription" => nil }
+    def convert_data context, data
+      service = context[:service]
+      case service
+      when "pubsub.googleapis.com"
+        data["messageId"] = context[:id]
+        data["publishTime"] = context[:timestamp]
+        [{ "message" => data }, nil]
+      when "firebaseauth.googleapis.com"
+        if data.key? "metadata"
+          FIREBASE_AUTH_METADATA_LEGACY_TO_CE.each do |old_key, new_key|
+            if data["metadata"].key? old_key
+              data["metadata"][new_key] = data["metadata"][old_key]
+              data["metadata"].delete old_key
+            end
+          end
+        end
+        subject = "users/#{data['uid']}" if data.key? "uid"
+        [data, subject]
       else
-        data
+        [data, nil]
       end
     end
 
@@ -116,8 +181,9 @@ module FunctionsFramework
       %r{^providers/cloud\.firestore/} => "firestore.googleapis.com",
       %r{^providers/cloud\.pubsub/}    => "pubsub.googleapis.com",
       %r{^providers/cloud\.storage/}   => "storage.googleapis.com",
-      %r{^providers/firebase\.auth/}   => "firebase.googleapis.com",
-      %r{^providers/google\.firebase}  => "firebase.googleapis.com"
+      %r{^providers/firebase\.auth/}   => "firebaseauth.googleapis.com",
+      %r{^providers/google\.firebase\.analytics/} => "firebase.googleapis.com",
+      %r{^providers/google\.firebase\.database/} => "firebasedatabase.googleapis.com"
     }.freeze
 
     LEGACY_TYPE_TO_CE_TYPE = {
@@ -140,5 +206,18 @@ module FunctionsFramework
       "providers/google.firebase.database/eventTypes/ref.delete" => "google.firebase.database.document.v1.deleted",
       "providers/cloud.storage/eventTypes/object.change"         => "google.cloud.storage.object.v1.finalized"
     }.freeze
+
+    CE_SERVICE_TO_RESOURCE_RE = {
+      "firebase.googleapis.com"         => %r{^(projects/[^/]+)/(events/[^/]+)$},
+      "firebasedatabase.googleapis.com" => %r{^projects/_/(instances/[^/]+)/(refs/.+)$},
+      "firestore.googleapis.com"        => %r{^(projects/[^/]+/databases/\(default\))/(documents/.+)$},
+      "storage.googleapis.com"          => %r{^(projects/[^/]+/buckets/[^/]+)/([^#]+)(?:#.*)?$}
+    }.freeze
+
+    # Map Firebase Auth legacy event metadata field names to their equivalent CloudEvent field names.
+    FIREBASE_AUTH_METADATA_LEGACY_TO_CE = {
+      "createdAt"      => "createTime",
+      "lastSignedInAt" => "lastSignInTime"
+    }.freeze
   end
 end

data/lib/functions_framework/server.rb

@@ -158,7 +158,7 @@ module FunctionsFramework
           ::Signal.trap "SIGHUP" do
             Server.signal_enqueue "SIGHUP", @config.logger, @server
           end
-        rescue ::ArgumentError # rubocop:disable Lint/HandleExceptions
+        rescue ::ArgumentError
           # Not available on all systems
         end
         @signals_installed = true
@@ -306,7 +306,7 @@ module FunctionsFramework
       # @return [Integer]
       #
       def max_threads
-        @max_threads || (@rack_env == "development" ? 1 : 16)
+        @max_threads || 1
       end
 
       ##
@@ -346,9 +346,9 @@ module FunctionsFramework
         when ::Rack::Response
           response.finish
         when ::String
-          string_response response, "text/plain", 200
+          string_response response, 200
         when ::Hash
-          string_response ::JSON.dump(response), "application/json", 200
+          string_response ::JSON.dump(response), 200, content_type: "application/json"
         when ::CloudEvents::CloudEventsError
           cloud_events_error_response response
         when ::StandardError
@@ -359,10 +359,17 @@ module FunctionsFramework
       end
 
       def notfound_response
-        string_response "Not found", "text/plain", 404
+        string_response "Not found", 404
       end
 
-      def string_response string, content_type, status
+      def string_response string, status, content_type: nil
+        string.force_encoding ::Encoding::ASCII_8BIT unless string.valid_encoding?
+        if string.encoding == ::Encoding::ASCII_8BIT
+          content_type ||= "application/octet-stream"
+        else
+          content_type ||= "text/plain"
+          content_type = "#{content_type}; charset=#{string.encoding.name.downcase}"
+        end
         headers = {
           "Content-Type"   => content_type,
           "Content-Length" => string.bytesize
@@ -372,13 +379,13 @@ module FunctionsFramework
 
       def cloud_events_error_response error
         @config.logger.warn error
-        string_response "#{error.class}: #{error.message}", "text/plain", 400
+        string_response "#{error.class}: #{error.message}", 400
       end
 
       def error_response message
         @config.logger.error message
         message = "Unexpected internal error" unless @config.show_error_details?
-        string_response message, "text/plain", 500
+        string_response message, 500
       end
     end
 
@@ -424,7 +431,7 @@ module FunctionsFramework
           when ::CloudEvents::Event
             handle_cloud_event event, logger
           when ::Array
-            ::CloudEvents::HttpContentError.new "Batched CloudEvents are not supported"
+            ::CloudEvents::CloudEventsError.new "Batched CloudEvents are not supported"
           when ::CloudEvents::CloudEventsError
             event
           else
@@ -436,9 +443,13 @@ module FunctionsFramework
       private
 
       def decode_event env
-        @cloud_events.decode_rack_env(env) ||
+        begin
+          @cloud_events.decode_event env
+        rescue ::CloudEvents::NotCloudEventError
+          env["rack.input"].rewind rescue nil
           @legacy_events.decode_rack_env(env) ||
-          raise(::CloudEvents::HttpContentError, "Unrecognized event format")
+            raise(::CloudEvents::CloudEventsError, "Unrecognized event format")
+        end
       rescue ::CloudEvents::CloudEventsError => e
         e
       end

data/lib/functions_framework/testing.rb

@@ -330,20 +330,27 @@ module FunctionsFramework
         when ::Array
           ::Rack::Response.new response[2], response[0], response[1]
         when ::String
-          string_response response, "text/plain", 200
+          string_response response, 200
         when ::Hash
           json = ::JSON.dump response
-          string_response json, "application/json", 200
+          string_response json, 200, content_type: "application/json"
         when ::StandardError
           message = "#{response.class}: #{response.message}\n#{response.backtrace}\n"
-          string_response message, "text/plain", 500
+          string_response message, 500
         else
           raise "Unexpected response type: #{response.inspect}"
         end
       end
 
       ## @private
-      def string_response string, content_type, status
+      def string_response string, status, content_type: nil
+        string.force_encoding ::Encoding::ASCII_8BIT unless string.valid_encoding?
+        if string.encoding == ::Encoding::ASCII_8BIT
+          content_type ||= "application/octet-stream"
+        else
+          content_type ||= "text/plain"
+          content_type = "#{content_type}; charset=#{string.encoding.name.downcase}"
+        end
         headers = {
           "Content-Type"   => content_type,
           "Content-Length" => string.bytesize
@@ -366,9 +373,10 @@ module FunctionsFramework
           ::Rack::RACK_ERRORS     => ::StringIO.new
         }
         headers.each do |header|
-          if header.is_a? String
+          case header
+          when String
             name, value = header.split ":"
-          elsif header.is_a? Array
+          when ::Array
             name, value = header
           end
           next unless name && value

data/lib/functions_framework/version.rb

@@ -17,5 +17,5 @@ module FunctionsFramework
   # Version of the Ruby Functions Framework
   # @return [String]
   #
-  VERSION = "0.7.1".freeze
+  VERSION = "1.0.0".freeze
 end

metadata

@@ -1,43 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: functions_framework
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-26 00:00:00.000000000 Z
+date: 2021-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cloud_events
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 2.a
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 2.a
 - !ruby/object:Gem::Dependency
   name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: 6.a
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: 6.a
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -87,10 +99,10 @@ homepage: https://github.com/GoogleCloudPlatform/functions-framework-ruby
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://googlecloudplatform.github.io/functions-framework-ruby/v0.7.1/file.CHANGELOG.html
+  changelog_uri: https://googlecloudplatform.github.io/functions-framework-ruby/v1.0.0/file.CHANGELOG.html
   source_code_uri: https://github.com/GoogleCloudPlatform/functions-framework-ruby
   bug_tracker_uri: https://github.com/GoogleCloudPlatform/functions-framework-ruby/issues
-  documentation_uri: https://googlecloudplatform.github.io/functions-framework-ruby/v0.7.1
+  documentation_uri: https://googlecloudplatform.github.io/functions-framework-ruby/v1.0.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -106,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Functions Framework for Ruby