pg_eventstore 1.10.0 → 1.12.0

data/lib/pg_eventstore/query_builders/partitions_filtering.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module QueryBuilders
+    # @!visibility private
+    class PartitionsFiltering < BasicFiltering
+      # @return [String]
+      TABLE_NAME = 'partitions'
+      private_constant :TABLE_NAME
+
+      class << self
+        # @param options [Hash]
+        # @return [Array<String>]
+        def extract_event_types_filter(options)
+          options in { filter: { event_types: Array => event_types } }
+          event_types&.select! do
+            _1.is_a?(String)
+          end
+          event_types || []
+        end
+
+        # @param options [Hash]
+        # @return [Array<Hash[Symbol, String]>]
+        def extract_streams_filter(options)
+          options in { filter: { streams: Array => streams } }
+          streams = streams&.map do
+            _1 in { context: String | NilClass => context }
+            _1 in { stream_name: String | NilClass => stream_name }
+            { context: context, stream_name: stream_name }
+          end
+          streams || []
+        end
+      end
+
+      # @return [String]
+      def to_table_name
+        TABLE_NAME
+      end
+
+      # @param context [String, nil]
+      # @param stream_name [String, nil]
+      # @return [void]
+      def add_stream_attrs(context: nil, stream_name: nil)
+        stream_attrs = { context: context, stream_name: stream_name }
+        return unless correct_stream_filter?(stream_attrs)
+
+        stream_attrs.compact!
+        sql = stream_attrs.map do |attr, _|
+          "#{to_table_name}.#{attr} = ?"
+        end.join(" AND ")
+        @sql_builder.where_or(sql, *stream_attrs.values)
+      end
+
+      # @param event_types [Array<String>]
+      # @return [void]
+      def add_event_types(event_types)
+        return if event_types.empty?
+
+        @sql_builder.where("#{to_table_name}.event_type = ANY(?::varchar[])", event_types)
+      end
+
+      # @return [void]
+      def with_event_types
+        @sql_builder.where('event_type IS NOT NULL')
+      end
+
+      private
+
+      # @param stream_attrs [Hash]
+      # @return [Boolean]
+      def correct_stream_filter?(stream_attrs)
+        result = (stream_attrs in { context: String, stream_name: String } | { context: String, stream_name: nil })
+        return true if result
+
+        PgEventstore&.logger&.debug(<<~TEXT)
+          Ignoring unsupported stream filter format for grouped read #{stream_attrs.compact.inspect}. \
+          See docs/reading_events.md docs for supported formats.
+        TEXT
+        false
+      end
+    end
+  end
+end

data/lib/pg_eventstore/sql_builder.rb

@@ -4,6 +4,16 @@ module PgEventstore
   # Deadly simple SQL builder
   # @!visibility private
   class SQLBuilder
+    class << self
+      # @param builders [Array<PgEventstore::SQLBuilder>]
+      # @return [PgEventstore::SQLBuilder]
+      def union_builders(builders)
+        builders[1..].each_with_object(builders[0]) do |builder, first_builder|
+          first_builder.union(builder)
+        end
+      end
+    end
+
     def initialize
       @select_values = []
       @from_value = nil

data/lib/pg_eventstore/subscriptions/callback_handlers/events_processor_handlers.rb

@@ -16,9 +16,9 @@ module PgEventstore
         callbacks.run_callbacks(:process, Utils.original_global_position(raw_event)) do
           handler.call(raw_event)
         end
-      rescue
+      rescue => exception
         raw_events.unshift(raw_event)
-        raise
+        raise Utils.wrap_exception(exception, global_position: Utils.original_global_position(raw_event))
       end
 
       # @param callbacks [PgEventstore::Callbacks]

data/lib/pg_eventstore/subscriptions/callback_handlers/subscription_runner_handlers.rb

@@ -26,7 +26,7 @@ module PgEventstore
       end
 
       # @param subscription [PgEventstore::Subscription]
-      # @param error [StandardError]
+      # @param error [PgEventstore::WrappedException]
       # @return [void]
       def update_subscription_error(subscription, error)
         subscription.update(last_error: Utils.error_info(error), last_error_occurred_at: Time.now.utc)
@@ -36,13 +36,13 @@ module PgEventstore
       # @param restart_terminator [#call, nil]
       # @param failed_subscription_notifier [#call, nil]
       # @param events_processor [PgEventstore::EventsProcessor]
-      # @param error [StandardError]
+      # @param error [PgEventstore::WrappedException]
       # @return [void]
       def restart_events_processor(subscription, restart_terminator, failed_subscription_notifier, events_processor,
                                    error)
         return if restart_terminator&.call(subscription.dup)
         if subscription.restart_count >= subscription.max_restarts_number
-          return failed_subscription_notifier&.call(subscription.dup, error)
+          return failed_subscription_notifier&.call(subscription.dup, Utils.unwrap_exception(error))
         end
 
         Thread.new do

data/lib/pg_eventstore/subscriptions/queries/subscription_queries.rb

@@ -127,7 +127,7 @@ module PgEventstore
     def subscriptions_events(query_options)
       return {} if query_options.empty?
 
-      final_builder = union_builders(query_options.map { |id, opts| query_builder(id, opts) })
+      final_builder = SQLBuilder.union_builders(query_options.map { |id, opts| query_builder(id, opts) })
       raw_events = connection.with do |conn|
         conn.exec_params(*final_builder.to_exec_params)
       end.to_a
@@ -177,14 +177,6 @@ module PgEventstore
       builder.select("#{id} as runner_id")
     end
 
-    # @param builders [Array<PgEventstore::SQLBuilder>]
-    # @return [PgEventstore::SQLBuilder]
-    def union_builders(builders)
-      builders[1..].each_with_object(builders[0]) do |builder, first_builder|
-        first_builder.union(builder)
-      end
-    end
-
     # @return [PgEventstore::TransactionQueries]
     def transaction_queries
       TransactionQueries.new(connection)

data/lib/pg_eventstore/utils.rb

@@ -46,11 +46,14 @@ module PgEventstore
       # @param error [StandardError]
       # @return [Hash]
       def error_info(error)
+        original_error = unwrap_exception(error)
         {
-          class: error.class,
-          message: error.message,
-          backtrace: error.backtrace
-        }
+          class: original_error.class,
+          message: original_error.message,
+          backtrace: original_error.backtrace
+        }.tap do |attrs|
+          attrs.merge!(error.extra) if error.is_a?(WrappedException)
+        end
       end
 
       # @param str [String]
@@ -82,7 +85,8 @@ module PgEventstore
       def write_to_file(file_path, content)
         file = File.open(file_path, "w")
         file.write(content)
-        file.close
+      ensure
+        file&.close
       end
 
       # @param file_path [String]
@@ -96,10 +100,25 @@ module PgEventstore
       # @return [String, nil]
       def read_pid(file_path)
         file = File.open(file_path, "r")
-        file.readline.strip.tap do
-          file.close
-        end
+        file.readline.strip
       rescue Errno::ENOENT
+      ensure
+        file&.close
+      end
+
+      # @param exception [StandardError]
+      # @param extra [Hash] additional exception info
+      # @return [PgEventstore::WrappedException]
+      def wrap_exception(exception, **extra)
+        WrappedException.new(exception, extra)
+      end
+
+      # @param wrapped_exception [StandardError, PgEventstore::WrappedException]
+      # @return [StandardError]
+      def unwrap_exception(wrapped_exception)
+        return wrapped_exception.original_exception if wrapped_exception.is_a?(WrappedException)
+
+        wrapped_exception
       end
     end
   end

data/lib/pg_eventstore/version.rb

@@ -2,5 +2,5 @@
 
 module PgEventstore
   # @return [String]
-  VERSION = "1.10.0"
+  VERSION = "1.12.0"
 end

data/lib/pg_eventstore/web/application.rb

@@ -13,6 +13,11 @@ module PgEventstore
       # @return [String]
       COOKIES_FLASH_MESSAGE_KEY = 'flash_message'
 
+      # Defines a replacement for empty string value in a stream attributes filter or in an event type filter. This
+      # replacement is needed to differentiate a user selection vs default placeholder value.
+      # @return [String]
+      EMPTY_STRING_SIGN = "\x00".freeze
+
       set :static_cache_control, [:private, max_age: 86400]
       set :environment, -> { (ENV['RACK_ENV'] || ENV['RAILS_ENV'] || ENV['APP_ENV'])&.to_sym || :development }
       set :logging, -> { environment == :development || environment == :test }
@@ -22,7 +27,7 @@ module PgEventstore
       helpers(Paginator::Helpers, Subscriptions::Helpers) do
         # @return [Array<Hash>, nil]
         def streams_filter
-          params in { filter: { streams: Array => streams } }
+          streams = QueryBuilders::EventsFiltering.extract_streams_filter(params)
           streams&.select { _1 in { context: String, stream_name: String, stream_id: String } }&.map do
             Hash[_1.reject { |_, value| value == '' }].transform_keys(&:to_sym)
           end&.reject { _1.empty? }
@@ -36,8 +41,9 @@ module PgEventstore
 
         # @return [Array<String>, nil]
         def events_filter
-          params in { filter: { events: Array => events } }
-          events&.select { _1.is_a?(String) && _1 != '' }
+          event_filters = { filter: { event_types: params.dig(:filter, :events) } }
+          events = QueryBuilders::EventsFiltering.extract_event_types_filter(event_filters)
+          events&.reject { _1 == '' }
         end
 
         # @return [Symbol]
@@ -69,8 +75,11 @@ module PgEventstore
         # @param collection [PgEventstore::Web::Paginator::BaseCollection]
         # @return [void]
         def paginated_json_response(collection)
+          results = collection.collection.map do |attrs|
+            attrs.transform_values { escape_empty_string(_1) }
+          end
           halt 200, {
-            results: collection.collection,
+            results: results,
             pagination: { more: !collection.next_page_starting_id.nil?, starting_id: collection.next_page_starting_id }
           }.to_json
         end
@@ -108,9 +117,25 @@ module PgEventstore
             COOKIES_FLASH_MESSAGE_KEY, { value: val, http_only: false, same_site: :lax, path: '/' }
           )
         end
+
+        # @param string [String, nil]
+        # @return [String, nil]
+        def escape_empty_string(string)
+          string == '' ? EMPTY_STRING_SIGN : string
+        end
+
+        # @param string [String, nil]
+        # @return [String, nil]
+        def unescape_empty_string(string)
+          string == EMPTY_STRING_SIGN ? '' : string
+        end
       end
 
       get '/' do
+        streams_filter = self.streams_filter&.map do |attrs|
+          attrs.transform_values { unescape_empty_string(_1) }
+        end
+        events_filter = self.events_filter&.map(&method(:unescape_empty_string))
         @collection = Paginator::EventsCollection.new(
           current_config,
           starting_id: params[:starting_id]&.to_i,
@@ -169,7 +194,7 @@ module PgEventstore
       get '/stream_contexts_filtering', provides: :json do
         collection = Paginator::StreamContextsCollection.new(
           current_config,
-          starting_id: params[:starting_id],
+          starting_id: unescape_empty_string(params[:starting_id]),
           per_page: Paginator::StreamContextsCollection::PER_PAGE,
           order: :asc,
           options: { query: params[:term] }
@@ -180,10 +205,10 @@ module PgEventstore
       get '/stream_names_filtering', provides: :json do
         collection = Paginator::StreamNamesCollection.new(
           current_config,
-          starting_id: params[:starting_id],
+          starting_id: unescape_empty_string(params[:starting_id]),
           per_page: Paginator::StreamNamesCollection::PER_PAGE,
           order: :asc,
-          options: { query: params[:term], context: params[:context] }
+          options: { query: params[:term], context: unescape_empty_string(params[:context]) }
         )
         paginated_json_response(collection)
       end
@@ -191,10 +216,14 @@ module PgEventstore
       get '/stream_ids_filtering', provides: :json do
         collection = Paginator::StreamIdsCollection.new(
           current_config,
-          starting_id: params[:starting_id],
+          starting_id: unescape_empty_string(params[:starting_id]),
           per_page: Paginator::StreamIdsCollection::PER_PAGE,
           order: :asc,
-          options: { query: params[:term], context: params[:context], stream_name: params[:stream_name] }
+          options: {
+            query: params[:term],
+            context: unescape_empty_string(params[:context]),
+            stream_name: unescape_empty_string(params[:stream_name])
+          }
         )
         paginated_json_response(collection)
       end
@@ -202,7 +231,7 @@ module PgEventstore
       get '/event_types_filtering', provides: :json do
         collection = Paginator::EventTypesCollection.new(
           current_config,
-          starting_id: params[:starting_id],
+          starting_id: unescape_empty_string(params[:starting_id]),
           per_page: Paginator::EventTypesCollection::PER_PAGE,
           order: :asc,
           options: { query: params[:term] }

data/lib/pg_eventstore/web/paginator/helpers.rb

@@ -88,9 +88,9 @@ module PgEventstore
               filter: {
                 streams: [
                   {
-                    context: event.stream.context,
-                    stream_name: event.stream.stream_name,
-                    stream_id: event.stream.stream_id
+                    context: escape_empty_string(event.stream.context),
+                    stream_name: escape_empty_string(event.stream.stream_name),
+                    stream_id: escape_empty_string(event.stream.stream_id)
                   }
                 ]
               }
@@ -98,6 +98,14 @@ module PgEventstore
           )
         end
 
+        # @param str [String]
+        # @return [String]
+        def empty_characters_fallback(str)
+          return str unless str.strip == ''
+
+          '<i>Non-printable characters</i>'
+        end
+
         private
 
         # @param starting_id [String, Integer, nil]

data/lib/pg_eventstore/web/public/javascripts/pg_eventstore.js

@@ -1,6 +1,30 @@
 $(function(){
     "use strict";
 
+    const EMPTY_STRING_SIGN = "\x00";
+
+    let templateSelection = function(state){
+        if (!state.id)
+            return state.text;
+
+        return filterValueToHuman(state.element && state.element.value, state.text);
+    }
+
+    let templateResult = function(item){
+        return filterValueToHuman(item.text);
+    }
+
+    let filterValueToHuman = function(str, alternativeStr){
+        if(str === EMPTY_STRING_SIGN)
+            return $("<i>Empty String</i>");
+
+        let result = alternativeStr || str;
+        if($.trim(result.replaceAll(EMPTY_STRING_SIGN, '')) === '')
+            return $("<i>Non-printable characters</i>");
+
+        return result;
+    }
+
     let initStreamFilterAutocomplete = function($filter) {
         let $contextSelect = $filter.find('select[name*="context"]');
         let $streamNameSelect = $filter.find('select[name*="stream_name"]');
@@ -22,7 +46,9 @@ $(function(){
                     return data;
                 },
             },
-            allowClear: true
+            allowClear: true,
+            templateSelection: templateSelection,
+            templateResult: templateResult,
         });
         $streamNameSelect.select2({
             ajax: {
@@ -41,7 +67,9 @@ $(function(){
                     return data;
                 },
             },
-            allowClear: true
+            allowClear: true,
+            templateSelection: templateSelection,
+            templateResult: templateResult,
         });
         $streamIdSelect.select2({
             ajax: {
@@ -61,7 +89,9 @@ $(function(){
                     return data;
                 },
             },
-            allowClear: true
+            allowClear: true,
+            templateSelection: templateSelection,
+            templateResult: templateResult,
         });
         $contextSelect.on('change.select2', removeDeleteBtn);
         $streamNameSelect.on('change.select2', removeDeleteBtn);
@@ -89,7 +119,9 @@ $(function(){
                     return data;
                 },
             },
-            allowClear: true
+            allowClear: true,
+            templateSelection: templateSelection,
+            templateResult: templateResult,
         });
     }
 
@@ -130,6 +162,11 @@ $(function(){
         initEventTypeFilterAutocomplete($filtersForm.find('.event-filters').children().last());
     });
 
+    // Because zero-byte character can't be rendered into HTML properly - loop through each option, marked as containing
+    // zero-byte value and assign zero-byte value explicitly. This must be done before we initialize select2 plugin.
+    $('option.zero-byte-val').each(function(){
+        this.value = EMPTY_STRING_SIGN;
+    });
     // Init select2 for stream filters which were initially rendered
     $filtersForm.find('.stream-filters').children().each(function(){
         initStreamFilterAutocomplete($(this));

data/lib/pg_eventstore/web/public/stylesheets/pg_eventstore.css

@@ -4,6 +4,18 @@ tr.collapsing {
     display: none;
 }
 
+td.json-cell {
+    max-width: 1px;
+}
+
+td.json-cell pre {
+    display: block;
+    width: 100%;
+    box-sizing: border-box;
+    overflow-x: auto;
+    white-space: pre;
+}
+
 #confirmation-modal .modal-body {
     font-size: 1.2rem;
 }

data/lib/pg_eventstore/web/views/home/partials/event_filter.erb

@@ -3,7 +3,11 @@
     <select name="filter[events][]" class="form-control mb-2" data-placeholder="Event type" data-url="<%= url('/event_types_filtering') %>" autocomplete="off">
       <option></option>
       <% if event_type %>
-        <option value="<%= h event_type %>" selected><%= h event_type %></option>
+        <% if event_type == PgEventstore::Web::Application::EMPTY_STRING_SIGN %>
+          <option class="zero-byte-val" selected></option>
+        <% else %>
+          <option value="<%= h event_type %>" selected><%= h event_type %></option>
+        <% end %>
       <% end %>
     </select>
   </div>

data/lib/pg_eventstore/web/views/home/partials/events.erb

@@ -2,17 +2,17 @@
   <tr>
     <td><%= event.global_position %></td>
     <td><%= event.stream_revision %></td>
-    <td><%= h event.stream.context %></td>
-    <td><%= h event.stream.stream_name %></td>
+    <td><%= empty_characters_fallback(h event.stream.context) %></td>
+    <td><%= empty_characters_fallback(h event.stream.stream_name) %></td>
     <td>
-      <a href="<%= stream_path(event) %>"><%= h event.stream.stream_id %></a>
+      <a href="<%= stream_path(event) %>"><%= empty_characters_fallback(h event.stream.stream_id) %></a>
       <a role="button" href="#" data-title="Copy stream definition." class="copy-to-clipboard"
          data-clipboard-content="<%= h "PgEventstore::Stream.new(context: #{event.stream.context.inspect}, stream_name: #{event.stream.stream_name.inspect}, stream_id: #{event.stream.stream_id.inspect})" %>">
         <i class="fa fa-clipboard"></i>
       </a>
     </td>
     <td>
-      <p class="float-left"><%= h event.type %></p>
+      <p class="float-left"><%= empty_characters_fallback(h event.type) %></p>
       <% if event.link %>
         <p class="float-left ml-2">
           <i class="fa fa-link"></i>
@@ -32,7 +32,7 @@
     </td>
   </tr>
   <tr class="event-payload d-none">
-    <td colspan="8">
+    <td colspan="9" class="json-cell">
       <strong>Data:</strong>
       <pre><%= h JSON.pretty_generate(event.data) %></pre>
       <strong>Metadata:</strong>

data/lib/pg_eventstore/web/views/home/partials/stream_filter.erb

@@ -3,7 +3,11 @@
     <select name="filter[streams][][context]" class="form-control mb-2" data-placeholder="Context" data-url="<%= url('/stream_contexts_filtering') %>" autocomplete="off">
       <option></option>
       <% if stream[:context] %>
-        <option value="<%= h stream[:context] %>" selected><%= h stream[:context] %></option>
+        <% if stream[:context] == PgEventstore::Web::Application::EMPTY_STRING_SIGN %>
+          <option class="zero-byte-val" selected></option>
+        <% else %>
+          <option value="<%= h stream[:context] %>" selected><%= h stream[:context] %></option>
+        <% end %>
       <% end %>
     </select>
   </div>
@@ -11,7 +15,11 @@
     <select name="filter[streams][][stream_name]" class="form-control mb-2" data-placeholder="Stream name" data-url="<%= url('/stream_names_filtering') %>" autocomplete="off">
       <option></option>
       <% if stream[:stream_name] %>
-        <option value="<%= h stream[:stream_name] %>" selected><%= h stream[:stream_name] %></option>
+        <% if stream[:stream_name] == PgEventstore::Web::Application::EMPTY_STRING_SIGN %>
+          <option class="zero-byte-val" selected></option>
+        <% else %>
+          <option value="<%= h stream[:stream_name] %>" selected><%= h stream[:stream_name] %></option>
+        <% end %>
       <% end %>
     </select>
   </div>
@@ -19,7 +27,11 @@
     <select name="filter[streams][][stream_id]" class="form-control mb-2" data-placeholder="Stream ID" data-url="<%= url('/stream_ids_filtering') %>" autocomplete="off">
       <option></option>
       <% if stream[:stream_id] %>
-        <option value="<%= h stream[:stream_id] %>" selected><%= h stream[:stream_id] %></option>
+        <% if stream[:stream_id] == PgEventstore::Web::Application::EMPTY_STRING_SIGN %>
+          <option class="zero-byte-val" selected></option>
+        <% else %>
+          <option value="<%= h stream[:stream_id] %>" selected><%= h stream[:stream_id] %></option>
+        <% end %>
       <% end %>
     </select>
   </div>

data/lib/pg_eventstore/web/views/subscriptions/index.erb

@@ -210,13 +210,13 @@
                             </td>
                           </tr>
                           <tr class="collapse" id="options-<%= subscription.id %>">
-                            <td colspan="16">
+                            <td colspan="16" class="json-cell">
                               <pre><%= h JSON.pretty_generate(subscription.options) %></pre>
                             </td>
                           </tr>
                           <% if subscription.last_error %>
                             <tr class="collapse" id="last-error-<%= subscription.id %>">
-                              <td colspan="16">
+                              <td colspan="16" class="json-cell">
                                 <pre><%= h JSON.pretty_generate(subscription.last_error) %></pre>
                               </td>
                             </tr>

data/lib/pg_eventstore.rb

@@ -9,6 +9,7 @@ require_relative 'pg_eventstore/extensions/callback_handlers_extension'
 require_relative 'pg_eventstore/extensions/using_connection_extension'
 require_relative 'pg_eventstore/event_class_resolver'
 require_relative 'pg_eventstore/config'
+require_relative 'pg_eventstore/partition'
 require_relative 'pg_eventstore/event'
 require_relative 'pg_eventstore/stream'
 require_relative 'pg_eventstore/commands'

data/sig/pg_eventstore/client.rbs

@@ -26,6 +26,8 @@ module PgEventstore
     # _@param_ `middlewares` — provide a list of middleware names to override a config's middlewares
     def read: (PgEventstore::Stream stream, ?options: ::Hash[untyped, untyped], ?middlewares: ::Array[::Symbol]?) -> ::Array[PgEventstore::Event]
 
+    def read_grouped: (Stream stream, ?options: Hash[untyped, untyped], ?middlewares: ::Array[::Symbol]?) -> ::Array[PgEventstore::Event]
+
     # _@param_ `stream`
     #
     # _@param_ `options` — request options

data/sig/pg_eventstore/commands/all_stream_read_grouped.rbs

@@ -0,0 +1,16 @@
+module PgEventstore
+  module Commands
+    class AllStreamReadGrouped < AbstractCommand
+
+      def call: (Stream stream, ?options: ::Hash[untyped, untyped]) -> Array[Event]
+
+      private
+
+      def build_filter_options_for_partitions: (Partition partition, Hash[untyped, untyped] options) -> Hash[untyped, untyped]
+
+      def build_filter_options_for_streams: (Partition partition, Array[String] stream_ids, Hash[untyped, untyped] options) -> Array[Hash[untyped, untyped]]
+
+      def group_stream_ids: (Hash[untyped, untyped] options) -> Hash[untyped, untyped]
+    end
+  end
+end

data/sig/pg_eventstore/commands/regular_stream_read_grouped.rbs

@@ -0,0 +1,8 @@
+module PgEventstore
+  module Commands
+    class RegularStreamReadGrouped < AbstractCommand
+
+      def call: (Stream stream, ?options: ::Hash[untyped, untyped]) -> Array[Event]
+    end
+  end
+end

data/sig/pg_eventstore/errors.rbs

@@ -123,4 +123,12 @@ module PgEventstore
 
     def user_friendly_message: -> String
   end
+
+  class WrappedException < PgEventstore::Error
+    def initialize: (StandardError original_exception, Hash[Symbol, untyped] extra) -> void
+
+    attr_accessor original_exception: StandardError
+
+    attr_accessor extra: Hash[Symbol, untyped]
+  end
 end

data/sig/pg_eventstore/partition.rbs

@@ -0,0 +1,15 @@
+module PgEventstore
+  class Partition
+    include Extensions::OptionsExtension
+
+    attr_accessor id: Integer
+
+    attr_accessor context: String
+
+    attr_accessor stream_name: String?
+
+    attr_accessor event_type: String?
+
+    attr_accessor table_name: String
+  end
+end