product_tours 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82d70df0c0b3463d2b4e49de5d2d8736c1ef50ab732a86bca87d5fcf2ebe0b51
+  data.tar.gz: 2e010ecadc7381f7176f6525cddc4ed93719dc07528fd4fb17d8c63852abcc24
+SHA512:
+  metadata.gz: f89e331dd2c34ffb12821a5f9159abc39c8f21bd78c6577048cdccf9895bed7eab76048a165234c8dd612f9c22a959440fc5d4d644eaa36807c3c6173a12e8d0
+  data.tar.gz: 3a34a6f113643ba9076c69805e586ca073187124de304f51ef6ebf353b9baba42c3f8c7c0f4a59e8118e9044185adc36bc79b93f4f01334a222336b7eca2c537

data/CHANGELOG.md

@@ -0,0 +1,41 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-08-03
+
+- Initial Rails engine, post dashboard, modal widget, video providers,
+  lifecycle notifications, installer, and demo seed task.
+- Linked Post actions with same-modal navigation, an in-memory Back stack, and
+  self-explanatory action choices in the dashboard.
+- Development installs now seed provider and multi-step demos automatically;
+  the installer and seed task print a copy-ready ERB trigger block.
+- Clarified the permanent host/gem boundary: host apps own trigger timing,
+  Help menus, analytics persistence, reporting, and vendor integrations.
+- Added immediate oEmbed-backed form previews, first-frame direct-video
+  previews, automatic CSP `frame-src` merging, language controls, key
+  normalization, and a simpler form layout.
+- Aligned the public modal shell and mobile behavior with the shared visual
+  patterns used by the `testimonials` and `ideasbugs` gems.
+- Added explicit Publish and Move to drafts dashboard actions, and linked the
+  seeded walkthrough through every supported video provider.
+- Aligned the admin dashboard with the shared sibling-gem page, card, queue,
+  detail, action, and responsive patterns; post metadata now lives in Details.
+- Added copy-ready launchers for a seeded draft post and an intentionally
+  missing key so developers can exercise both unresolved-trigger paths.
+- Reduced configuration to host gating, layout, mount path, and optional storage;
+  locale resolution now follows current then default locale, production failures
+  report through `Rails.error`, and lifecycle payloads contain no gem-owned user,
+  tenant, or visitor identity.
+- Renamed admin-facing records to tutorials, put Published before Draft, made
+  identity fields full-width, and replaced simultaneous URL/upload inputs with a
+  clear video-source choice.
+- Simplified lifecycle notifications to tutorial, page, and source context;
+  removed navigation/progress metadata and inconsistent video-ended completion.
+- Made the default locale the canonical admin tutorial list; new product tours now
+  start in that locale and translations are added and opened from each tutorial.
+- Removed generic tutorial duplication now that translations provide the only
+  intentional content-copying workflow.
+
+[Unreleased]: https://github.com/yshmarov/product_tours/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/yshmarov/product_tours/releases/tag/v0.1.0

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Yaroslav Shmarov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,209 @@
+# product_tours
+
+[![CI](https://github.com/yshmarov/product_tours/actions/workflows/ci.yml/badge.svg)](https://github.com/yshmarov/product_tours/actions/workflows/ci.yml)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](MIT-LICENSE)
+
+`product_tours` is a self-hosted Rails engine for in-app product tutorials and
+lightweight multi-step walkthroughs. Your app owns the trigger UI; the gem owns
+the tutorial editor, translations, safe video embeds, and modal navigation.
+
+Requires Ruby 3.2+ and Rails 7.1+.
+
+## Install
+
+```ruby
+gem "product_tours"
+```
+
+```bash
+bin/rails generate product_tours:install
+bin/rails db:migrate
+```
+
+The migration automatically creates ready-to-use demo tutorials in development.
+Production databases are never populated with demo content.
+
+Add the widget before `</body>` in your application layout:
+
+```erb
+<%= product_tours_tag %>
+```
+
+Use any host-owned button, link, or icon as the trigger:
+
+```erb
+<button class="btn btn-primary" data-product-tour="billing_setup">
+  Watch setup guide
+</button>
+```
+
+Create and publish `billing_setup` in the dashboard at `/product_tours`. Keys
+are unique per locale. Draft, missing, invalid, or disabled keys open nothing
+and raise in development/test; production reports them through `Rails.error`
+and `product_tours.unresolved_trigger` instrumentation.
+
+### Host-controlled invocation
+
+The host app decides where and when a guide opens. It can use a visible button,
+compose several buttons into its own Help menu, or activate a hidden trigger
+after page load. For example, Rails flash state and a host Stimulus controller
+can open a guide after a redirect:
+
+```erb
+<% if flash[:product_tour].present? %>
+  <button hidden
+          data-controller="product-tour-autoplay"
+          data-product-tour="<%= flash[:product_tour] %>"></button>
+<% end %>
+```
+
+```js
+// product_tour_autoplay_controller.js in the host app
+connect() {
+  this.element.click()
+}
+```
+
+The gem deliberately has no page-rule engine, automatic display scheduler,
+resource center, or guides launcher. Those are host navigation and presentation
+choices built from the same `data-product-tour` attribute.
+
+## Tutorials
+
+A tutorial is stored internally as a `ProductTours::Post`. It has a title, key,
+locale, `draft`/`published` status,
+optional video, optional rich description, and one primary action. Video URLs
+support YouTube, Vimeo, Loom, Tella, Voomly, and direct MP4/WebM files.
+
+The dashboard previews a pasted video URL immediately. YouTube, Vimeo, and Loom
+metadata is fetched through oEmbed; the other supported providers still get a
+safe resolved preview. Direct videos seek to an early frame so they do not look
+like an empty player before playback.
+
+The admin sidebar treats `I18n.default_locale` as the canonical tutorial list.
+The New product tour button always creates that default-language record. Open a
+tutorial to see its existing languages or add another available locale; each
+translation remains an ordinary draft/published `Post` with the same key.
+
+When the host has a Rails Content Security Policy, the engine preserves its
+existing `frame-src` entries and automatically adds the supported embed origins.
+For a direct video hosted on a custom origin, the host remains responsible for
+allowing that origin in `media-src` (or can allow HTTPS media generally).
+
+### Link tutorials into a walkthrough
+
+In the tutorial editor, choose what the primary button does: finish and close,
+open a page, or continue to another tutorial. Continuing opens the selected
+tutorial in the
+same modal and automatically gives visitors a Back button.
+
+Tutorials remain independently invokable—there is no separate course, step, or
+sequence model. The Back history exists only for the open modal, so a tutorial opened
+directly never shows a misleading Back button.
+
+Video uploads require Active Storage:
+
+```bash
+bin/rails active_storage:install
+bin/rails db:migrate
+```
+
+Rich descriptions require Action Text:
+
+```bash
+bin/rails action_text:install
+bin/rails db:migrate
+```
+
+The post form hides either feature when its Rails framework is not installed.
+
+## Demo tutorials
+
+The installer seeds the app's default locale in development. Copy the block it
+prints into any ERB view to open every demo entry point immediately:
+
+```erb
+<div class="product-tours-demo">
+  <button type="button" data-product-tour="demo_walkthrough_start">Try the multi-step walkthrough</button>
+  <button type="button" data-product-tour="demo_youtube">Open the YouTube tutorial</button>
+  <button type="button" data-product-tour="demo_vimeo">Open the Vimeo tutorial</button>
+  <button type="button" data-product-tour="demo_loom">Open the Loom tutorial</button>
+  <button type="button" data-product-tour="demo_tella">Open the Tella tutorial</button>
+  <button type="button" data-product-tour="demo_voomly">Open the Voomly tutorial</button>
+  <button type="button" data-product-tour="demo_direct_video">Open the direct video tutorial</button>
+  <button type="button" data-product-tour="demo_getting_started">Open the getting started guide</button>
+  <button type="button" data-product-tour="demo_draft">Try an unpublished tutorial</button>
+  <button type="button" data-product-tour="demo_missing_post">Try a missing tutorial</button>
+</div>
+<%= product_tours_tag %>
+```
+
+`demo_walkthrough_start` introduces the collection, then continues through the
+YouTube, Vimeo, Loom, Tella, Voomly, and direct-video tutorials before its final
+step. Every transition demonstrates the automatic Back button. The individual
+provider buttons remain available so each video can also be opened directly.
+The final two buttons deliberately exercise unresolved triggers: `demo_draft`
+exists but remains unpublished, while `demo_missing_post` is never seeded.
+
+Refresh the full idempotent demo set in English, French, and Bulgarian at any
+time:
+
+```bash
+bin/rails product_tours:seed_demo
+```
+
+Along with the provider examples, it creates `demo_walkthrough_start`,
+`demo_walkthrough_features`, `demo_walkthrough_finish`, and the unpublished
+`demo_draft` in the default demo locales (`en`, `fr`, and `bg`). The missing-key
+button intentionally has no matching record. Running the task again refreshes
+the seeded records instead of duplicating them and prints the copy-ready block
+again. To seed only one locale from application code, call
+`ProductTours::Seeds.load!(locale: :fr)`.
+
+## Configuration
+
+The installer creates `config/initializers/product_tours.rb`. Important hooks:
+
+```ruby
+ProductTours.configure do |config|
+  config.authorize_admin = ->(request) { request.env["warden"]&.user&.admin? }
+end
+```
+
+Tutorial lookup automatically uses the page's current `I18n.locale`, then falls
+back to `I18n.default_locale` when that key has no current-locale record. An
+existing draft translation is not bypassed by the fallback.
+
+## Lifecycle Notifications
+
+The widget emits `product_tours.viewed`, `product_tours.dismissed`, and
+`product_tours.completed` through `ActiveSupport::Notifications`. The gem does
+not persist analytics and does not depend on Ahoy. `completed` means the visitor
+used the tutorial's primary action; video playback does not imply completion.
+
+```ruby
+ActiveSupport::Notifications.subscribe(/^product_tours\./) do |name, _start, _finish, _id, payload|
+  Ahoy.track(name.delete_prefix("product_tours."), payload.slice(:key, :locale, :source))
+end
+```
+
+The host may store these events with Ahoy and attach its own user or account
+context in the subscriber. Persistence, dashboards, identity, and vendor-specific
+integrations remain outside this gem.
+
+## Scope
+
+`product_tours` owns tutorial persistence and editing, safe media rendering, the
+modal experience, linked-tutorial navigation, and lifecycle notifications. The host
+app owns trigger timing and placement, Help/resource menus, analytics storage,
+reporting, and downstream integrations.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+bundle exec rubocop
+```
+
+Rails 7.1+ and Ruby 3.2+ are supported.

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |task|
+  task.libs << 'test'
+  task.pattern = 'test/**/*_test.rb'
+end
+
+task default: :test

data/app/controllers/product_tours/application_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module ProductTours
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    private
+
+    def product_tours_admin_layout
+      ProductTours.config.admin_layout
+    end
+
+    def require_admin
+      return if ProductTours.admin?(request)
+
+      render plain: 'Forbidden. Set ProductTours.config.authorize_admin to grant access.', status: :forbidden
+    end
+
+    def current_product_tours_locale
+      requested_locale = params[:locale].to_s
+      return requested_locale if I18n.available_locales.map(&:to_s).include?(requested_locale)
+
+      ProductTours.locale(request)
+    end
+
+    def find_post_by_locale(scope, key)
+      locales = [current_product_tours_locale, I18n.default_locale.to_s].uniq
+      posts = scope.where(locale: locales, key: key).index_by(&:locale)
+      locales.filter_map { |locale| posts[locale] }.first
+    end
+
+    def clean_page_url(value)
+      uri = URI.parse(value.to_s)
+      return unless uri.is_a?(URI::HTTP) && uri.host.present?
+
+      uri.query = nil
+      uri.fragment = nil
+      uri.to_s
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def unresolved_payload(key, reason)
+      {
+        key: key.to_s,
+        locale: current_product_tours_locale,
+        reason: reason.to_s,
+        page_url: clean_page_url(params[:page_url])
+      }
+    end
+
+    def handle_unresolved_trigger(key, reason)
+      payload = unresolved_payload(key, reason)
+      error = ProductTours::UnresolvedTriggerError.new(payload)
+      raise error if Rails.env.development? || Rails.env.test?
+
+      if defined?(Rails.error) && Rails.error.respond_to?(:report)
+        Rails.error.report(error, handled: true, context: payload)
+      else
+        Rails.logger.error("product_tours: #{error.message} #{payload.inspect}")
+      end
+      ActiveSupport::Notifications.instrument('product_tours.unresolved_trigger', payload)
+      render json: { error: 'unresolved_trigger', reason: reason.to_s }, status: :not_found
+    end
+  end
+end

data/app/controllers/product_tours/media_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ProductTours
+  class MediaController < ApplicationController
+    def show
+      post = Post.find(params[:id])
+      allowed = ProductTours.admin?(request) || (ProductTours.enabled?(request) && post.published?)
+      return head :forbidden unless allowed
+      return head :not_found unless post.uploaded_video?
+
+      redirect_to main_app.rails_blob_path(post.video, disposition: 'inline')
+    end
+  end
+end

data/app/controllers/product_tours/posts_controller.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module ProductTours
+  class PostsController < ApplicationController
+    PER_PAGE = 50
+
+    layout :product_tours_admin_layout
+    before_action :require_admin
+    before_action :set_post,
+                  only: %i[show edit update destroy refresh_video_metadata add_translation publish unpublish]
+    before_action :load_linkable_posts, only: %i[new create edit update]
+    before_action :load_translations, only: :show
+
+    def index
+      @status = Post::STATUSES.include?(params[:status]) ? params[:status] : 'published'
+      @query = params[:q].to_s.strip.presence
+      @counts = Post.where(locale: default_locale).group(:status).count
+
+      key_scope = Post.where(status: @status, locale: default_locale)
+      @keys = key_scope.distinct.order(:key).pluck(:key)
+
+      scope = posts_with_video.newest_first.where(status: @status, locale: default_locale)
+      scope = scope.where('LOWER(key) LIKE ?', "%#{Post.sanitize_sql_like(@query.downcase)}%") if @query
+      @page = [params[:page].to_i, 1].max
+      @posts = scope.offset((@page - 1) * PER_PAGE).limit(PER_PAGE + 1).to_a
+      @more = @posts.size > PER_PAGE
+      @posts = @posts.first(PER_PAGE)
+
+      @selected_post = posts_with_video.find_by(id: params[:post_id]) if params[:post_id].present?
+      load_translations if @selected_post
+    end
+
+    def show; end
+
+    def new
+      @post = Post.new(locale: default_locale)
+    end
+
+    def create
+      @post = Post.new(post_attributes.merge(locale: default_locale))
+      if @post.save
+        redirect_to post_path(@post), notice: t('product_tours.dashboard.created', default: 'Tutorial created.')
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def edit; end
+
+    def update
+      if @post.update(post_attributes)
+        remove_uploaded_video if remove_uploaded_video?
+        redirect_to post_path(@post), notice: t('product_tours.dashboard.updated', default: 'Tutorial updated.')
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      if default_locale_post?(@post) && translations_for(@post).where.not(id: @post.id).exists?
+        redirect_to post_path(@post),
+                    alert: t('product_tours.dashboard.delete_translations_first',
+                             default: 'Delete this tutorial\'s translations before deleting the ' \
+                                      'default-language tutorial.')
+        return
+      end
+
+      @post.destroy!
+      redirect_to posts_path,
+                  notice: t('product_tours.dashboard.deleted', default: 'Tutorial deleted.'), status: :see_other
+    end
+
+    def add_translation
+      locale = params[:locale].to_s
+      unless available_locales.include?(locale) && locale != @post.locale
+        redirect_to post_path(@post),
+                    alert: t('product_tours.dashboard.translation_locale_invalid',
+                             default: 'Choose another available language.')
+        return
+      end
+
+      existing = Post.find_by(locale: locale, key: @post.key)
+      if existing
+        redirect_to post_path(existing),
+                    notice: t('product_tours.dashboard.translation_exists',
+                              default: 'That translation already exists.')
+        return
+      end
+
+      source = translations_for(@post).find_by(locale: default_locale) || @post
+      translation = source.dup
+      translation.locale = locale
+      translation.status = 'draft'
+      if translation.action_post_key.present? &&
+         !Post.exists?(locale: locale, key: translation.action_post_key)
+        translation.action_post_key = nil
+      end
+      translation.save!
+      if Post.description_supported? && source.description.present?
+        translation.update!(description: source.description.body)
+      end
+      translation.video.attach(source.video.blob) if source.uploaded_video?
+
+      redirect_to edit_post_path(translation),
+                  notice: t('product_tours.dashboard.translation_added',
+                            default: 'Translation added as a draft. Translate its content before publishing.')
+    end
+
+    def publish
+      @post.update!(status: 'published')
+      redirect_to post_path(@post), notice: t('product_tours.dashboard.published', default: 'Tutorial published.')
+    end
+
+    def unpublish
+      @post.update!(status: 'draft')
+      redirect_to post_path(@post),
+                  notice: t('product_tours.dashboard.unpublished', default: 'Tutorial moved to drafts.')
+    end
+
+    def video_preview
+      resolved = VideoResolver.resolve(params[:url])
+      unless resolved
+        render json: { error: t('product_tours.dashboard.video_invalid', default: 'Enter a supported video URL.') },
+               status: :unprocessable_entity
+        return
+      end
+
+      metadata = VideoMetadata.fetch(params[:url])
+      render json: {
+        kind: resolved.kind,
+        provider: resolved.provider,
+        url: resolved.url,
+        title: metadata['provider_title'],
+        thumbnail_url: metadata['thumbnail_url']
+      }.compact
+    end
+
+    def refresh_video_metadata
+      metadata = VideoMetadata.fetch(@post.video_url)
+      if metadata.present?
+        @post.update!(video_metadata: @post.video_metadata.to_h.merge(metadata))
+        redirect_to edit_post_path(@post),
+                    notice: t('product_tours.dashboard.metadata_updated', default: 'Video data refreshed.')
+      else
+        redirect_to edit_post_path(@post),
+                    alert: t('product_tours.dashboard.metadata_failed',
+                             default: 'Video data could not be fetched. The URL was not changed.')
+      end
+    end
+
+    private
+
+    def posts_with_video
+      Post.video_upload_supported? ? Post.with_attached_video : Post.all
+    end
+
+    def set_post
+      @post = Post.find(params[:id])
+    end
+
+    def post_params
+      permitted = %i[key status title video_url action_label action_url action_post_key]
+      permitted << :description if Post.description_supported?
+      permitted << :video if Post.video_upload_supported?
+      params.require(:post).permit(*permitted)
+    end
+
+    def post_attributes
+      attributes = post_params
+      attributes.delete(:key) if identity_locked?
+      case params[:video_source]
+      when 'url'
+        attributes.delete(:video)
+      when 'upload'
+        attributes[:video_url] = nil
+      end
+      case params[:action_target]
+      when 'close'
+        attributes[:action_url] = nil
+        attributes[:action_post_key] = nil
+      when 'url'
+        attributes[:action_post_key] = nil
+      when 'post'
+        attributes[:action_url] = nil
+      end
+      attributes
+    end
+
+    def load_linkable_posts
+      @linkable_posts = Post.where.not(id: @post&.id).order(:locale, :title, :key)
+                            .select(:id, :key, :locale, :status, :title)
+      @identity_locked = identity_locked?
+    end
+
+    def load_translations
+      post = @selected_post || @post
+      @translations = translations_for(post).order(:locale).to_a
+      @missing_translation_locales = available_locales - @translations.map(&:locale)
+    end
+
+    def translations_for(post)
+      Post.where(key: post.key)
+    end
+
+    def available_locales
+      (I18n.available_locales.map(&:to_s) + [default_locale]).uniq.sort
+    end
+
+    def default_locale
+      I18n.default_locale.to_s
+    end
+
+    def default_locale_post?(post)
+      post.locale == default_locale
+    end
+
+    def identity_locked?
+      @post&.persisted? &&
+        (!default_locale_post?(@post) || translations_for(@post).where.not(id: @post.id).exists?)
+    end
+
+    def remove_uploaded_video?
+      params[:video_source] == 'url' && @post.uploaded_video?
+    end
+
+    def remove_uploaded_video
+      @post.video.purge if @post.uploaded_video?
+    end
+  end
+end

data/app/controllers/product_tours/tours_controller.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ProductTours
+  class ToursController < ApplicationController
+    SIGNALS = %w[viewed dismissed completed].freeze
+
+    def resolve
+      key = params[:key].to_s
+      return handle_unresolved_trigger(key, :disabled) unless ProductTours.enabled?(request)
+      return handle_unresolved_trigger(key, :invalid_key) unless key.match?(Post::KEY_FORMAT)
+
+      post = find_post_by_locale(Post.all, key)
+      return handle_unresolved_trigger(key, :missing) unless post
+      return handle_unresolved_trigger(key, :unpublished) unless post.published?
+
+      render json: post_payload(post)
+    end
+
+    def signal
+      return head :forbidden unless ProductTours.enabled?(request)
+
+      action = params[:event_action].to_s
+      return head :unprocessable_entity unless SIGNALS.include?(action)
+
+      post = find_post_by_locale(Post.published, params[:key].to_s)
+      return head :not_found unless post
+
+      payload = {
+        post_id: post.id,
+        key: post.key,
+        locale: post.locale,
+        page_url: clean_page_url(params[:page_url]),
+        source: params[:source].to_s.presence
+      }
+      ActiveSupport::Notifications.instrument("product_tours.#{action}", payload)
+      head :no_content
+    end
+
+    private
+
+    def post_payload(post)
+      video = post.resolved_video
+      video[:url] = media_path(post) if video&.dig(:kind) == 'upload'
+      {
+        key: post.key,
+        locale: post.locale,
+        title: post.title,
+        descriptionHtml: description_html(post),
+        video: video,
+        action: {
+          label: post.action_label.presence || default_action_label(post),
+          url: post.action_url.presence,
+          postKey: post.action_post_key.presence
+        }
+      }
+    end
+
+    def default_action_label(post)
+      key = post.action_post_key.present? ? :next : :done
+      I18n.t(key, scope: :product_tours, default: key.to_s.humanize)
+    end
+
+    def description_html(post)
+      return unless Post.description_supported? && post.description.present?
+
+      post.description.body.to_s
+    end
+  end
+end