volcano-sdk 0.31.0 → 0.32.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36cf6c142c98f421f086d919b4d5e83034e95831d2b4246a892be57ebfaea9d5
-  data.tar.gz: 877909af108367683c4cbb434235baa27669af9d303dd0b52307919446f8c348
+  metadata.gz: b0f776d6ce8242c9e13c9bda50c0a57656288bfe4ff5e14f88e75c19a7609ded
+  data.tar.gz: 25436052f65e6ededb49df00688a2e7d4076a233ca84502a2503dc470d1ab6d5
 SHA512:
-  metadata.gz: 832893a1b1ba6caa88f144b81d8b8e155d2041be82fccffe4328eeb1f59f4fc8e3ce84adbb476f3b1a6b26ed719da7293f9dfb6a563270cdcb5222125661f378
-  data.tar.gz: acfb489b98c3e8dcca7918ee1136d4e04f62fec2a7287fcc16fcd952edd3bfae2d4973b6307ef53d577a08cb4104511666917e4435c3d7722bb3cde544d7ad3d
+  metadata.gz: 0da1887ccafe797e2169899402489b9eab52d6587782461fd0390dfc63041ebe0a134e6ab89dc42d9ab5e5acf2dae34332516b2727f4bc51726f078319d58205
+  data.tar.gz: fce88e25d637dfb1dda8bb10b279e0dbfcbe621e4912ca1c941460eb1e94b6cc4b1e84242402b692ba19a66c0cab89992ea14d826beef3710629970dd361353f

data/README.md

@@ -505,26 +505,32 @@ handle = client.durable.start(
   execution_name: "order-9"
 )
 
-execution = client.durable.get(project_id, "charge-order", handle.id)
+owner_client = Volcano::Client.new(
+  api_url: "https://api.volcano.dev",
+  anon_key: ENV.fetch("VOLCANO_ANON_KEY"),
+  access_token: ENV.fetch("VOLCANO_PLATFORM_TOKEN")
+)
+execution = owner_client.durable.get(project_id, "charge-order", handle.id)
 puts [execution.status, execution.terminal?, execution.result]
 
-page = client.durable.list(project_id, "charge-order", status: "running")
+page = owner_client.durable.list(project_id, "charge-order", status: "running")
 puts [page.total, page.has_more]
 
-client.durable.stop(project_id, "charge-order", handle.id)
+owner_client.durable.stop(project_id, "charge-order", handle.id)
 ```
 
 `start` takes a durable function's name or its id and returns a handle, never a
-result: an execution can run for hours, so its result is read back with `get`.
+result: an execution can run for up to 366 days, so its result is read back with `get`.
 It uses the same credential `invoke` does — the active user session, then a
 configured service key, then the anonymous key — and is the only durable
 operation an application credential may perform. An `execution_name` makes the
 start idempotent: starting again under the same name returns the execution that
 already exists rather than beginning a second one.
 
-`get`, `list`, and `stop` are owner-scoped and require a platform token or a
-configured service key, because an execution is addressed by its id alone. An
-auth-user session from sign-in is not accepted. `get` carries the deeply
+`get`, `list`, and `stop` are owner-scoped and require the project owner's
+platform user token, because an execution is addressed by its id alone.
+Auth-user sessions, anonymous keys, service keys, and project access tokens are
+not accepted. `get` carries the deeply
 frozen `result` once the execution has succeeded, and `error` when it failed;
 `result_expired` separates a result the platform has discarded from a function
 that returned nothing. `terminal?` reports whether the execution has stopped

data/lib/volcano/database.rb

@@ -1,33 +1,21 @@
 # frozen_string_literal: true
 
+# Ruby SDK runtime and immutable database builders.
 module Volcano
-  # Captures caller-owned query values before storing them in immutable builders.
-  module ImmutableQueryValue
-    module_function
-
-    def capture(value)
-      case value
-      when String then value.dup.freeze
-      when Array then value.map { |item| capture(item) }.freeze
-      when Hash then capture_hash(value)
-      else value
-      end
-    end
-
-    def capture_hash(value)
-      value.to_h { |key, item| [capture(key), capture(item)] }.freeze
-    end
-  end
-  private_constant :ImmutableQueryValue
-
   QueryContext = Data.define(:client, :transport, :database_name)
   private_constant :QueryContext
   QueryState = Data.define(:columns, :filters, :order, :limit, :offset)
   private_constant :QueryState
+  # @type var empty_columns: Array[String]
+  empty_columns = []
+  empty_columns.freeze
+  # @type var empty_conditions: Array[query_condition]
+  empty_conditions = []
+  empty_conditions.freeze
   EMPTY_QUERY_STATE = QueryState.new(
-    columns: [].freeze,
-    filters: [].freeze,
-    order: [].freeze,
+    columns: empty_columns,
+    filters: empty_conditions,
+    order: empty_conditions,
     limit: nil,
     offset: nil
   )
@@ -35,6 +23,7 @@ module Volcano
 
   # Adds the shared immutable filter vocabulary to database builders.
   module FilterMethods
+    # @dynamic copy
     def eq(column, value) = add_filter(column, 'eq', value)
     def neq(column, value) = add_filter(column, 'neq', value)
     def gt(column, value) = add_filter(column, 'gt', value)
@@ -50,9 +39,9 @@ module Volcano
 
     def add_filter(column, operator, value)
       condition = {
-        'column' => ImmutableQueryValue.capture(column),
+        'column' => ImmutableRequestValue.capture(column),
         'operator' => operator,
-        'value' => ImmutableQueryValue.capture(value)
+        'value' => ImmutableRequestValue.capture(value)
       }.freeze
       copy(filters: [*@filters, condition])
     end
@@ -62,7 +51,7 @@ module Volcano
   # Creates immutable queries scoped to one project database.
   class Database
     def initialize(client, transport, name)
-      database_name = ImmutableQueryValue.capture(name)
+      database_name = ImmutableRequestValue.capture(name)
       @context = QueryContext.new(client:, transport:, database_name:)
     end
 
@@ -77,7 +66,7 @@ module Volcano
 
     def initialize(context, table, state: EMPTY_QUERY_STATE)
       @context = context
-      @table = ImmutableQueryValue.capture(table)
+      @table = ImmutableRequestValue.capture(table)
       @columns = state.columns
       @filters = state.filters
       @order = state.order
@@ -87,13 +76,13 @@ module Volcano
     end
 
     def select(*columns)
-      copy(columns: ImmutableQueryValue.capture(columns))
+      copy(columns: ImmutableRequestValue.capture(columns))
     end
 
-    def insert(values) = InsertBuilder.new(@context, @table, ImmutableQueryValue.capture(values))
+    def insert(values) = InsertBuilder.new(@context, @table, ImmutableRequestValue.capture(values))
 
     def update(values)
-      UpdateBuilder.new(@context, @table, ImmutableQueryValue.capture(values), filters: @filters)
+      UpdateBuilder.new(@context, @table, ImmutableRequestValue.capture(values), filters: @filters)
     end
 
     def delete
@@ -101,7 +90,7 @@ module Volcano
     end
 
     def order(column, ascending: true)
-      clause = { 'column' => ImmutableQueryValue.capture(column), 'ascending' => ascending }.freeze
+      clause = { 'column' => ImmutableRequestValue.capture(column), 'ascending' => ascending }.freeze
       copy(order: [*@order, clause])
     end
 
@@ -123,7 +112,7 @@ module Volcano
           )
         end
       end
-      Transport.body(response, 200).fetch('data')
+      Transport.json_rows(Transport.body(response, 200))
     end
 
     private
@@ -149,7 +138,9 @@ module Volcano
     end
 
     def query_body
-      { 'table' => @table }.tap do |body|
+      # @type var body: sdk_payload
+      body = { 'table' => @table }
+      body.tap do |body|
         add_query_selection(body)
         body['limit'] = @limit unless @limit.nil?
         body['offset'] = @offset unless @offset.nil?
@@ -184,7 +175,7 @@ module Volcano
           )
         end
       end
-      Transport.body(response, 200).fetch('data')
+      Transport.json_rows(Transport.body(response, 200))
     end
   end
 
@@ -192,7 +183,7 @@ module Volcano
   class UpdateBuilder
     include FilterMethods
 
-    def initialize(context, table, values, filters: [].freeze)
+    def initialize(context, table, values, filters: EMPTY_QUERY_STATE.filters)
       @context = context
       @table = table
       @values = values
@@ -210,7 +201,7 @@ module Volcano
           )
         end
       end
-      Transport.body(response, 200).fetch('data')
+      Transport.json_rows(Transport.body(response, 200))
     end
 
     private
@@ -224,7 +215,7 @@ module Volcano
   class DeleteBuilder
     include FilterMethods
 
-    def initialize(context, table, filters: [].freeze)
+    def initialize(context, table, filters: EMPTY_QUERY_STATE.filters)
       @context = context
       @table = table
       @filters = filters
@@ -241,7 +232,7 @@ module Volcano
           )
         end
       end
-      Transport.body(response, 200).fetch('data')
+      Transport.json_rows(Transport.body(response, 200))
     end
 
     private

data/lib/volcano/durable.rb

@@ -40,10 +40,10 @@ module Volcano
 
     # Reads an execution, including its result once it has succeeded.
     #
-    # Owner-scoped: an execution is addressed by its id alone and an anon key
-    # is held by everyone who loads the page, so this takes the project id and
-    # a platform token or service key. An auth-user session from sign-in is
-    # not enough. Poll it from a backend, not a browser.
+    # Owner-scoped: an execution is addressed by its id alone, so this takes
+    # the project id and the project owner's platform user token. Auth-user
+    # sessions, anon keys, service keys, and project access tokens are not
+    # accepted. Poll it from a backend, not a browser.
     def get(project_id, function_name, execution_id)
       project, function_id, execution = execution_path(project_id, function_name, execution_id)
       response = Transport.invoke do
@@ -100,7 +100,7 @@ module Volcano
     # An empty path segment would address the collection instead of the
     # execution, which is a different request rather than a failed one.
     def identifier(value, field)
-      raise ArgumentError, "#{field} must be a non-empty String" unless present_string?(value)
+      raise ArgumentError, "#{field} must be a non-empty String" unless value.is_a?(String) && present_string?(value)
 
       value.strip.freeze
     end
@@ -128,7 +128,7 @@ module Volcano
     end
 
     def validate_page_limit(limit)
-      return if limit.nil? || (positive_integer?(limit) && limit <= MAX_PAGE_SIZE)
+      return if limit.nil? || (limit.is_a?(Integer) && positive_integer?(limit) && limit <= MAX_PAGE_SIZE)
 
       raise ArgumentError, "limit must be an Integer between 1 and #{MAX_PAGE_SIZE}"
     end

data/lib/volcano/durable_models.rb

@@ -15,9 +15,16 @@ module Volcano
   private_constant :DURABLE_TERMINAL_STATUSES
 
   # Why a failed or timed-out execution ended.
-  DurableExecutionError = Data.define(:type, :message) do
+  DurableExecutionError = Data.define(:type, :message)
+
+  # Reopens the generated record for checked initialization.
+  class DurableExecutionError
+    # @dynamic type, message, members, with, to_h, deconstruct, deconstruct_keys
+    # @dynamic self.[], self.members
     def initialize(type: nil, message: nil)
-      super(type: type&.dup&.freeze, message: message&.dup&.freeze)
+      type = type&.dup&.freeze
+      message = message&.dup&.freeze
+      super
     end
   end
 
@@ -27,7 +34,13 @@ module Volcano
   # once its retention lapses. That is not the same as a function that returned
   # nothing, so read `result_expired` before concluding anything from a missing
   # result.
-  DurableExecution = Data.define(*DURABLE_EXECUTION_ATTRIBUTES) do
+  DurableExecution = Data.define(*DURABLE_EXECUTION_ATTRIBUTES)
+
+  # Reopens the generated record for checked initialization.
+  class DurableExecution
+    # @dynamic id, function_id, name, status, region, created_at, result, result_expired
+    # @dynamic error, completed_at, members, with, to_h, deconstruct, deconstruct_keys
+    # @dynamic self.[], self.members
     def initialize(**attributes)
       unknown = attributes.keys - DURABLE_EXECUTION_ATTRIBUTES
       raise ArgumentError, "unknown keywords: #{unknown.join(', ')}" unless unknown.empty?
@@ -38,7 +51,8 @@ module Volcano
       values = DURABLE_EXECUTION_ATTRIBUTES.to_h do |name|
         [name, immutable_value(attributes[name])]
       end
-      super(**values)
+      attributes = values
+      super
     end
 
     # Reports whether the execution has stopped changing.
@@ -64,12 +78,15 @@ module Volcano
   end
 
   # One page of a durable function's executions, most recent first.
-  DurableExecutionPage = Data.define(:executions, :page, :limit, :total, :has_more) do
+  DurableExecutionPage = Data.define(:executions, :page, :limit, :total, :has_more)
+
+  # Reopens the generated record for checked initialization.
+  class DurableExecutionPage
+    # @dynamic executions, page, limit, total, has_more, members, with, to_h
+    # @dynamic deconstruct, deconstruct_keys, self.[], self.members
     def initialize(executions:, page:, limit:, total:, has_more:)
-      super(
-        executions: executions.to_a.dup.freeze,
-        page: page, limit: limit, total: total, has_more: has_more
-      )
+      executions = executions.to_a.dup.freeze
+      super
     end
   end
 
@@ -77,18 +94,17 @@ module Volcano
   module DurableResponses
     INCOMPLETE_EXECUTION = 'Expected a complete durable execution'
     INCOMPLETE_PAGE = 'Expected a complete durable execution page'
-    EXECUTION_FIELDS = %w[id function_id name status region].freeze
-    private_constant :INCOMPLETE_EXECUTION, :INCOMPLETE_PAGE, :EXECUTION_FIELDS
+    private_constant :INCOMPLETE_EXECUTION, :INCOMPLETE_PAGE
 
     private
 
     def durable_execution(payload)
       values = execution_payload(payload)
       DurableExecution.new(
-        id: values.fetch('id'), function_id: values.fetch('function_id'),
-        name: values.fetch('name'), status: values.fetch('status'),
-        region: values.fetch('region'), created_at: parse_time(values.fetch('created_at')),
-        result: values['result'], result_expired: values['result_expired'],
+        id: execution_text(values, 'id'), function_id: execution_text(values, 'function_id'),
+        name: execution_text(values, 'name'), status: execution_text(values, 'status'),
+        region: execution_text(values, 'region'), created_at: execution_time(values),
+        result: execution_result(values['result']), result_expired: execution_expired(values['result_expired']),
         error: execution_error(values['error']), completed_at: parse_time(values['completed_at'])
       )
     end
@@ -96,12 +112,36 @@ module Volcano
     def execution_payload(payload)
       raise TypeError, INCOMPLETE_EXECUTION unless payload.is_a?(Hash)
 
-      complete = EXECUTION_FIELDS.all? { |field| present_string?(payload[field]) }
-      raise TypeError, INCOMPLETE_EXECUTION unless complete && payload['created_at']
-
       payload
     end
 
+    def execution_text(values, field)
+      value = values[field]
+      raise TypeError, INCOMPLETE_EXECUTION unless value.is_a?(String) && !value.strip.empty?
+
+      value
+    end
+
+    def execution_time(values)
+      case (value = values['created_at'])
+      when String then Time.iso8601(value)
+      when Time then value
+      else raise TypeError, INCOMPLETE_EXECUTION
+      end
+    end
+
+    def execution_expired(value)
+      return value if value.nil? || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+      raise TypeError, INCOMPLETE_EXECUTION
+    end
+
+    def execution_result(value)
+      Transport.json_value(value)
+    rescue TypeError
+      raise TypeError, INCOMPLETE_EXECUTION, cause: nil
+    end
+
     def execution_error(payload)
       return if payload.nil?
       raise TypeError, INCOMPLETE_EXECUTION unless payload.is_a?(Hash)
@@ -110,10 +150,10 @@ module Volcano
     end
 
     def durable_execution_page(payload)
-      data, has_more = page_payload(payload)
+      values, data, has_more = page_payload(payload)
       DurableExecutionPage.new(
         executions: data.map { |entry| durable_execution(entry) }, has_more: has_more,
-        page: count(payload['page']), limit: count(payload['limit']), total: count(payload['total'])
+        page: count(values['page']), limit: count(values['limit']), total: count(values['total'])
       )
     end
 
@@ -124,7 +164,7 @@ module Volcano
       has_more = payload['has_more']
       raise TypeError, INCOMPLETE_PAGE unless data.is_a?(Array) && [true, false].include?(has_more)
 
-      [data, has_more]
+      [payload, data, has_more]
     end
 
     def count(value)
@@ -138,7 +178,10 @@ module Volcano
     end
 
     def parse_time(value)
-      value.is_a?(String) ? Time.iso8601(value) : value
+      return Time.iso8601(value) if value.is_a?(String)
+      return value if value.nil? || value.is_a?(Time)
+
+      raise TypeError, INCOMPLETE_EXECUTION
     end
   end
   private_constant :DurableResponses

data/lib/volcano/function_auth.rb

@@ -32,7 +32,7 @@ module Volcano
 
     def refresh(original)
       # Resolution has released its cache lock before refresh callbacks run.
-      @client.auth.__send__(:refresh_captured_session, @binding)
+      @client.auth.__send__(:refresh_captured_session, active_binding)
     rescue Error::SessionChangedError
       raise
     rescue Error::VolcanoError
@@ -41,11 +41,18 @@ module Volcano
 
     def validate
       if @binding.last
-        @client.auth.__send__(:validate_read_failure, @binding)
+        @client.auth.__send__(:validate_read_failure, active_binding)
       elsif @client.capture_session_binding[1] != @binding[1]
         raise Error::SessionChangedError
       end
     end
+
+    def active_binding
+      generation, owner, session = @binding
+      raise Error::SessionChangedError unless session
+
+      [generation, owner, session]
+    end
   end
   private_constant :FunctionAuth
 end

data/lib/volcano/functions.rb

@@ -3,6 +3,9 @@
 require_relative 'function_auth'
 
 module Volcano
+  INVALID_FUNCTION_NAME = 'Function name must be DNS-safe: lowercase letters, numbers, and hyphens; 1-63 characters'
+  private_constant :INVALID_FUNCTION_NAME
+
   # Invokes deployed Volcano functions by name.
   class Functions
     FUNCTION_NAME = /\A[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\z/
@@ -21,7 +24,7 @@ module Volcano
     def invoke(name, payload = {})
       auth = FunctionAuth.new(@client)
       validate_invocation(name, payload)
-      invoke_owned(auth, name.dup.freeze, ImmutableQueryValue.capture(payload))
+      invoke_owned(auth, name.dup.freeze, ImmutableRequestValue.capture(payload))
     end
 
     private
@@ -53,9 +56,7 @@ module Volcano
     # X-Volcano-Function-Invoked only after dispatch, so its absence is what
     # separates the two. X-Volcano-Version cannot: the server stamps it on every
     # response, including errors raised before the function is reached.
-    def stale_mapping?(response)
-      response.status == 404 && header(response.headers, FUNCTION_INVOKED_HEADER).nil?
-    end
+    def stale_mapping?(response) = response.status == 404 && header(response.headers, FUNCTION_INVOKED_HEADER).nil?
 
     def invoke_resolved(authorization, resolution, payload)
       if resolution.invoke_url.nil?
@@ -77,8 +78,8 @@ module Volcano
       # Hold the name's lock across the round trip so concurrent callers wait
       # for one resolve instead of each opening their own.
       FunctionResolution.resolve_lock(@api_url, authorization, name).synchronize do
-        cached = FunctionResolution.lookup(@api_url, authorization, name)
-        next cached_resolution(cached) if cached
+        cached_under_lock = FunctionResolution.lookup(@api_url, authorization, name)
+        next cached_resolution(cached_under_lock) if cached_under_lock
 
         resolve_uncached(authorization, name)
       end
@@ -88,7 +89,7 @@ module Volcano
       resolved = Transport.invoke do
         @transport.resolve_function_for_invocation(authorization: authorization, name: name)
       end
-      payload = Transport.body(resolved, 200)
+      payload = Transport.json_object(Transport.body(resolved, 200), message: 'Expected a complete function response')
       resolution = resolved_resolution(payload)
       FunctionResolution.store(@api_url, authorization, name, resolution, cache_ttl(payload))
       resolution
@@ -98,24 +99,26 @@ module Volcano
     end
 
     def cached_resolution(cached)
-      cached.resolution || raise(FunctionResolution.error_for(cached.failure))
+      return cached.resolution if cached.resolution
+
+      failure = cached.failure || raise(TypeError, 'Expected a cached function resolution')
+      raise FunctionResolution.error_for(failure)
     end
 
     def validate_invocation(name, payload)
-      unless name.is_a?(String) && FUNCTION_NAME.match?(name)
-        raise ArgumentError,
-              'Function name must be DNS-safe: lowercase letters, numbers, and hyphens; 1-63 characters'
-      end
+      raise ArgumentError, INVALID_FUNCTION_NAME unless name.is_a?(String) && FUNCTION_NAME.match?(name)
       raise TypeError, 'Function payload must be a Hash' unless payload.is_a?(Hash)
     end
 
     def resolved_resolution(payload)
-      function_id = payload['function_id'] if payload.is_a?(Hash)
+      payload = Transport.json_object(payload)
+      function_id = payload['function_id']
       raise TypeError, 'Expected a complete function response' unless function_id.is_a?(String) && !function_id.empty?
 
       # Absent when the deployment serves no public invocation domain, as in
       # local development; the function is reached through the API instead.
-      invoke_url = FunctionResolution.valid_invoke_url(payload['invoke_url'], @api_url)
+      candidate = payload['invoke_url']
+      invoke_url = FunctionResolution.valid_invoke_url(candidate.is_a?(String) ? candidate : nil, @api_url)
       FunctionResolution::Resolution.new(function_id: function_id, invoke_url: invoke_url)
     end
 
@@ -136,7 +139,7 @@ module Volcano
       Transport.body(response, 200) unless response.status.between?(200, 299) || dispatched
 
       FunctionResponse.new(
-        data: response.body, status: response.status,
+        data: Transport.json_value(response.body), status: response.status,
         headers: response.headers || {}, version: version
       )
     end

data/lib/volcano/immutable_request_value.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Ruby SDK runtime and immutable caller-owned request values.
+module Volcano
+  # Copies JSON-like request values before storing them in builders or sending them.
+  module ImmutableRequestValue
+    def self.capture(value)
+      case value
+      when String, Time then value.dup.freeze
+      when Array then value.map { |item| capture(item) }.freeze
+      when Hash then capture_hash(value)
+      else value
+      end
+    end
+
+    def self.capture_hash(value)
+      value.to_h { |key, item| [capture(key), capture(item)] }.freeze
+    end
+  end
+  private_constant :ImmutableRequestValue
+end

data/lib/volcano/logs.rb

@@ -3,8 +3,6 @@
 module Volcano
   # Searches retained project logs and activity.
   class Logs
-    include ImmutableLogJSON
-
     def initialize(client, transport)
       @client = client
       @transport = transport
@@ -46,26 +44,27 @@ module Volcano
       end
       raise TypeError, 'Log request must be a Hash' unless request.is_a?(Hash)
 
-      [project_id.dup.freeze, immutable_json(request)]
+      [project_id.dup.freeze, ImmutableRequestValue.capture(request)]
     end
 
     def search_response(body)
-      data = response_data(body)
+      body, data = response_data(body)
       limit = body['limit']
       has_more = body['has_more']
       next_cursor = body['next_cursor']
-      unless limit.is_a?(Integer) && [true, false].include?(has_more) &&
-             (next_cursor.nil? || next_cursor.is_a?(String))
+      unless limit.is_a?(Integer) && boolean?(has_more) && (next_cursor.nil? || next_cursor.is_a?(String))
         raise TypeError, 'Expected a complete log response'
       end
 
+      has_more = has_more == true
+
       LogSearchResponse.new(
         data: data, limit: limit, has_more: has_more, next_cursor: next_cursor
       )
     end
 
     def activity_response(body)
-      data = response_data(body)
+      body, data = response_data(body)
       total = body['total']
       raise TypeError, 'Expected a complete log response' unless total.is_a?(Integer)
 
@@ -73,10 +72,16 @@ module Volcano
     end
 
     def response_data(body)
-      data = body['data'] if body.is_a?(Hash)
+      raise TypeError, 'Expected a complete log response' unless body.is_a?(Hash)
+
+      data = body['data']
       raise TypeError, 'Expected a complete log response' unless data.is_a?(Array) && data.all?(Hash)
 
-      data
+      [body, data]
+    end
+
+    def boolean?(value)
+      value.is_a?(TrueClass) || value.is_a?(FalseClass)
     end
   end
 end