studio-engine 0.82.0 → 0.83.0

data/app/controllers/concerns/studio/link_preview_bots.rb

@@ -27,6 +27,14 @@ module Studio
   #
   # People, in-app browsers and unknown agents are never matched and always get
   # the full page. The allow-list is Studio::LinkPreview::BOT_TOKENS.
+  #
+  # ALLOW_BROWSER: Rails 8's `allow_browser versions: :modern` (in every new
+  # app's ApplicationController) answers Apple's LinkPresentation — which sends a
+  # Safari 9.0.1 User-Agent — with a 406, so no iMessage preview. Including this
+  # concern exempts preview fetchers from every allow_browser guard on the
+  # controller, GET and HEAD only, with no app code. An app that already wrote
+  # `allow_browser ..., unless: :link_preview_bot_request?` keeps working: its
+  # guard never runs for a fetcher, so this override is never reached.
   module LinkPreviewBots
     extend ActiveSupport::Concern
 
@@ -47,6 +55,24 @@ module Studio
 
     private
 
+    # Rails' allow_browser macro installs
+    # `before_action -> { allow_browser(versions:, block:) }`, which dispatches to
+    # the PRIVATE instance method ActionController::AllowBrowser#allow_browser (the
+    # same in Rails 7.2.3 and 8.1.4). This concern is included below
+    # ActionController::Base, so it sits above that module in the ancestor chain and
+    # this method answers first: a preview fetcher's GET/HEAD skips the browser
+    # check, everything else goes to Rails. Overriding the method rather than
+    # skipping the callback covers every allow_browser declaration (this
+    # controller, a parent or a subclass, before or after the include), and a
+    # lambda callback cannot be named to skip_before_action anyway. The integration
+    # suite pins the method, so a Rails rename fails loudly
+    # (test/integration/link_preview_test.rb).
+    def allow_browser(*args, **kwargs, &block)
+      return if link_preview_bot_request?
+
+      super
+    end
+
     def serve_link_preview_slim_document
       return unless link_preview_bot_request?
       return unless response.status == 200
@@ -55,13 +81,30 @@ module Studio
       body = response.body
       return unless body.is_a?(String) && !body.empty?
 
-      response.body = Studio::LinkPreview.slim_document(body, url: request.original_url)
+      response.body = Studio::LinkPreview.slim_document(body, url: studio_link_preview_page_url)
       response.headers[SLIM_HEADER] = "slim"
       # A shared cache must never hand the slim page to a person.
       response.headers["Vary"] = [response.headers["Vary"], "User-Agent"].compact.join(", ")
     rescue StandardError => e
       # The full page is still a valid (if large) answer; never 500 a fetcher.
-      Rails.logger&.warn("[studio.link_preview] slim render skipped: #{e.class}: #{e.message}")
+      # The failure goes to ErrorLog (and Sentry, when the host loads it) so it
+      # is triaged rather than lost in a log line; never re-raised, because the
+      # response is already rendered and the fetcher must still get the page.
+      studio_link_preview_capture(e)
+    end
+
+    def studio_link_preview_capture(error)
+      ErrorLog.capture!(error)
+    rescue StandardError, NameError => capture_error
+      Rails.logger&.warn("[studio.link_preview] slim render skipped: #{error.class}: #{error.message} " \
+                         "(ErrorLog unavailable: #{capture_error.class})")
+    end
+
+    # The page's canonical URL for the slim card's link: Studio.link_preview_base_url
+    # plus the path when the app pins one, else the URL as requested.
+    def studio_link_preview_page_url
+      Studio::LinkPreview.page_url(base_url: Studio.link_preview_base_url,
+                                   request_url: request.original_url, path: request.path)
     end
   end
 end

data/app/controllers/studio/bookings_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Studio
+  # /schedule — the app's booking page: Google Calendar's appointment page
+  # inline (studio/booking/_frame), inside the host's own layout.
+  #
+  # Public by design: it is where every "Schedule a call" link lands when the
+  # popup cannot open, so it skips the host's sign-in gate
+  # (mcritchie-industries and cyvasse gate every controller through
+  # Studio::ErrorHandling). It inherits the host's ApplicationController so the
+  # page renders in the app's layout, navbar and theme.
+  #
+  # Drawn only when the host opts in (Studio.draw_booking_routes). With no
+  # Studio.booking_url there is nothing to book, and it answers 404.
+  class BookingsController < ::ApplicationController
+    skip_before_action :require_authentication, raise: false
+
+    def show
+      head :not_found if Studio.booking_url.blank?
+    end
+  end
+end

data/app/controllers/studio/site_identities_controller.rb

@@ -27,7 +27,7 @@ module Studio
       @uploads_available = @installed && @setting.respond_to?(:image)
       @default_image_url = default_image_url
       @static_image_url = static_image_url
-      @domain = request.host
+      @domain = preview_domain
     end
 
     def update
@@ -95,13 +95,25 @@ module Studio
     # The uploaded image as the card shows it: the same URL the head emits.
     def default_image_url
       stored = Studio::SiteIdentity.stored
-      Studio::LinkPreview.absolute_url(stored[:image_url] || stored[:image_path], base_url: request.base_url)
+      Studio::LinkPreview.absolute_url(stored[:image_url] || stored[:image_path], base_url: preview_base_url)
     rescue StandardError
       nil
     end
 
+    # The same base the head's tags are built on (Studio.link_preview_base_url,
+    # else this request's), so the card shows the domain and URL an unfurl does.
+    def preview_base_url
+      Studio::LinkPreview.base_url(pinned: Studio.link_preview_base_url, request_base_url: request.base_url)
+    end
+
+    def preview_domain
+      URI.parse(preview_base_url.to_s).host || request.host
+    rescue URI::InvalidURIError
+      request.host
+    end
+
     def static_image_url
-      Studio::LinkPreview.absolute_url(Studio::SiteIdentity.static_image, base_url: request.base_url)
+      Studio::LinkPreview.absolute_url(Studio::SiteIdentity.static_image, base_url: preview_base_url)
     end
   end
 end

data/app/helpers/studio/link_preview_helper.rb

@@ -10,7 +10,7 @@ module Studio
   # reason Studio::GeoHelper gives: every helper module is included into every
   # view, so an unprefixed name would collide with a host's own helper.
   module LinkPreviewHelper
-    OVERRIDE_KEYS = %i[image title description].freeze
+    OVERRIDE_KEYS = %i[image title description image_alt].freeze
 
     # THE PAGE OVERRIDE. Call it from any view (the layout renders later, so it
     # sees the call):
@@ -22,6 +22,8 @@ module Studio
     # attachment/blob (a user's avatar). An image that is nil, blank, or an
     # attachment with nothing attached falls back to the operator's default, so
     # a page can pass `image: user.avatar` without asking whether there is one.
+    # `image_alt:` is the image's text alternative (og:image:alt); without it the
+    # card's title stands in, which is what the picture illustrates.
     # Only the keys passed are set; a second call overrides just its own keys.
     # Returns nil, so `<%= link_preview ... %>` prints nothing either.
     def link_preview(**overrides)
@@ -33,8 +35,14 @@ module Studio
     end
 
     # The resolved preview for this page:
-    # { title:, description:, image:, image_source:, site_name:, url: }.
-    # `image` is absolute (or nil). Never raises: a preview must not 500 a page.
+    # { title:, description:, image:, image_source:, image_width:, image_height:,
+    #   image_alt:, site_name:, url: }.
+    # `image` is absolute (or nil). `image_width`/`image_height` are the
+    # winning image's pixel size when it is KNOWN — an attachment whose blob has
+    # been analyzed, or the static fallback file — and nil otherwise; a URL handed
+    # in as a string is never fetched to measure it. `url` is the page's og:url
+    # (Studio.link_preview_base_url plus the path when the app pins one).
+    # Never raises: a preview must not 500 a page.
     #
     # Rungs, most specific first: the page's `link_preview`, then the page's
     # own content_for(:title) / content_for(:meta_description) /
@@ -43,21 +51,27 @@ module Studio
     def studio_link_preview
       overrides = @studio_link_preview_overrides || {}
       stored = studio_site_identity_stored
+      override_image = studio_link_preview_image_location(overrides[:image])
 
       preview = Studio::LinkPreview.resolve(
         site_name: Studio.app_name,
         titles: [overrides[:title], studio_link_preview_content(:title), stored[:title], Studio.site_title],
         descriptions: [overrides[:description], studio_link_preview_content(:meta_description),
                        stored[:description], Studio.site_description],
-        page_images: [studio_link_preview_image_location(overrides[:image]), studio_link_preview_content(:og_image)],
+        page_images: [override_image, studio_link_preview_content(:og_image)],
         default_image: stored[:image_url] || stored[:image_path],
         static_image: Studio::SiteIdentity.static_image
       )
 
+      width, height = studio_link_preview_image_size(preview[:image_source], overrides[:image], override_image, stored)
+
       preview.merge(
         image: Studio::LinkPreview.absolute_url(preview[:image], base_url: studio_request_base_url) || preview[:image],
+        image_width: width,
+        image_height: height,
+        image_alt: (overrides[:image_alt].to_s.strip.presence || preview[:title] if preview[:image]),
         site_name: Studio.app_name.to_s,
-        url: (request.original_url if respond_to?(:request) && request)
+        url: studio_link_preview_page_url
       )
     end
 
@@ -106,8 +120,42 @@ module Studio
       value && CGI.unescapeHTML(value.to_str)
     end
 
+    # The app's pinned canonical base (Studio.link_preview_base_url), else the
+    # request's. Every preview URL is built on it.
     def studio_request_base_url
-      respond_to?(:request) && request ? request.base_url : nil
+      Studio::LinkPreview.base_url(pinned: Studio.link_preview_base_url,
+                                   request_base_url: (request.base_url if studio_link_preview_request?))
+    end
+
+    def studio_link_preview_page_url
+      return nil unless studio_link_preview_request?
+
+      Studio::LinkPreview.page_url(base_url: Studio.link_preview_base_url,
+                                   request_url: request.original_url, path: request.path)
+    end
+
+    def studio_link_preview_request?
+      respond_to?(:request) && request ? true : false
+    end
+
+    # [width, height] of the image that won, when it is known without a fetch.
+    # The override rung counts only when the page handed in an ATTACHMENT (its
+    # blob's analyzed metadata); a URL string or a content_for(:og_image) is
+    # unmeasured, so its tags are left out rather than guessed.
+    def studio_link_preview_image_size(source, override, override_location, stored)
+      case source
+      when :page
+        return nil if override_location.nil? || override.is_a?(String) || override.is_a?(Symbol)
+
+        Studio::SiteIdentity.image_dimensions(override)
+      when :default
+        width, height = stored[:image_width], stored[:image_height]
+        width && height ? [width, height] : nil
+      when :static
+        Studio::SiteIdentity.static_image_dimensions
+      end
+    rescue StandardError
+      nil
     end
   end
 end

data/app/helpers/studio/site_footer_helper.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Studio
+  # The site footer and the booking primitives, as view helpers. See
+  # docs/SITE_FOOTER.md.
+  #
+  #   <%= studio_site_footer %>             the footer, where it should show
+  #   <%= studio_booking_frame %>           Google's booking page, inline
+  #   <%= studio_booking_link "Book a call", class: "btn btn-primary" %>
+  #   <%= studio_booking_popup %>           the dialog those links open
+  #   <%= studio_footer_map %>              the map alone, e.g. on a contact page
+  #
+  # Every one of them renders NOTHING when its configuration is absent
+  # (Studio.site_footer, Studio.booking_url), so a layout or a shared view can
+  # call them before an app has declared anything.
+  #
+  # Prefixed names for the reason Studio::GeoHelper gives: every helper module is
+  # included into every view.
+  module SiteFooterHelper
+    # The resolved facts (Studio::SiteFooter.resolve), or nil. Resolved once per
+    # request.
+    #
+    # A callable that RAISES must not take every page down with it, because the
+    # footer is in the layout. In production the error is logged once per process
+    # and the page renders with no footer; locally it raises, so whoever wrote the
+    # callable sees it.
+    def studio_site_footer_facts
+      return @_studio_site_footer_facts if defined?(@_studio_site_footer_facts)
+
+      @_studio_site_footer_facts =
+        begin
+          Studio.site_footer_for(self)
+        rescue StandardError => error
+          raise if studio_site_footer_raise?
+
+          studio_site_footer_report(error)
+          nil
+        end
+    end
+
+    # Where the footer shows: Studio.site_footer_visible, asked of this view. By
+    # default that is every page for a visitor and, for a signed-in viewer, only
+    # the controllers in Studio.site_footer_controllers (plus the engine's booking
+    # page). Always false for an app that declared no footer.
+    def studio_show_site_footer?
+      return false if studio_site_footer_facts.nil?
+
+      Studio.site_footer_visible.call(self) ? true : false
+    end
+
+    # The one layout line. Renders the footer (and, with a booking_url, the
+    # booking popup) where studio_show_site_footer? says it belongs.
+    def studio_site_footer
+      return unless studio_show_site_footer?
+
+      render "studio/site_footer/footer", facts: studio_site_footer_facts
+    end
+
+    # The live map alone. With no arguments it maps the footer's address;
+    # pass lat:/lng: (and street:/city_line:/directions_url:) to map another.
+    # `class:` and `style:` size it: the element has no height of its own.
+    def studio_footer_map(address = nil, **options)
+      address = address ? Studio::SiteFooter.address(Studio::SiteFooter.symbolize(address)) : studio_site_footer_facts&.dig(:address)
+      return unless address && address[:map]
+
+      render "studio/site_footer/map", address: address, classes: options[:class], style: options[:style],
+                                       zoom: options[:zoom], controls: options.fetch(:controls, true)
+    end
+
+    # ---- booking ------------------------------------------------------------
+
+    def studio_booking? = Studio.booking_url.present?
+
+    # Google's embeddable page for the configured schedule (with gv=true).
+    def studio_booking_embed_url = Studio::Booking.embed_url(Studio.booking_url)
+
+    # Where a booking link goes when the popup cannot open (scripts off, a
+    # modified click, a page with no dialog): the app's booking page when the
+    # engine draws it, else Google's own page.
+    def studio_booking_fallback_path
+      return studio_booking_path if Studio.draw_booking_routes && respond_to?(:studio_booking_path)
+
+      Studio.booking_url
+    end
+
+    # The frame's accessible name.
+    def studio_booking_title(title = nil)
+      title.presence || studio_site_footer_facts&.dig(:booking_title) ||
+        "#{studio_booking_label} with #{studio_site_footer_name}"
+    end
+
+    # What the booking links, the popup and the booking page call the act.
+    def studio_booking_label
+      studio_site_footer_facts&.dig(:booking_label) || Studio::SiteFooter::DEFAULT_BOOKING_LABEL
+    end
+
+    # The site's name: the footer's, else the site identity's title.
+    def studio_site_footer_name
+      studio_site_footer_facts&.dig(:name) || Studio.site_identity[:title]
+    end
+
+    # The inline booking frame. `crop: false` shows Google's whole page at rest.
+    def studio_booking_frame(title: nil, crop: true)
+      return unless studio_booking?
+
+      render "studio/booking/frame", title: studio_booking_title(title), crop: crop
+    end
+
+    # The booking dialog, once per page however often it is asked for. The
+    # footer renders it; call this yourself only on a page that has booking
+    # links and no footer.
+    def studio_booking_popup(label: nil, title: nil)
+      return unless studio_booking?
+      return if @_studio_booking_popup_rendered
+
+      @_studio_booking_popup_rendered = true
+      render "studio/booking/popup",
+             label: label.presence || studio_booking_label,
+             title: studio_booking_title(title)
+    end
+
+    # A link that opens the booking popup in place. Its href is the fallback, so
+    # it is an ordinary link wherever the popup is unavailable. With no
+    # booking_url and no href there is nowhere to go, and it renders nothing.
+    #
+    #   <%= studio_booking_link %>                                  "Schedule a call"
+    #   <%= studio_booking_link "Book a call", class: "btn btn-primary" %>
+    #   <%= studio_booking_link "Book a call", contact_path %>      your own fallback
+    def studio_booking_link(name = nil, href = nil, html_options = nil, **options, &block)
+      html_options, href = href, nil if href.is_a?(Hash)
+      html_options, name = name, nil if name.is_a?(Hash)
+      html_options = (html_options || {}).merge(options)
+      href ||= studio_booking_fallback_path
+      return if href.blank?
+
+      html_options[:data] = { booking_popup: true, studio_booking: true }.merge(html_options[:data] || {}) if studio_booking?
+      content = block ? capture(&block) : (name || studio_booking_label)
+      link_to(content, href, html_options)
+    end
+
+    # ---- once-per-page assets -----------------------------------------------
+
+    def studio_site_footer_assets
+      return if @_studio_site_footer_assets_rendered
+
+      @_studio_site_footer_assets_rendered = true
+      render "studio/site_footer/assets"
+    end
+
+    def studio_booking_assets
+      return if @_studio_booking_assets_rendered
+
+      @_studio_booking_assets_rendered = true
+      render "studio/booking/assets"
+    end
+
+    private
+
+    def studio_site_footer_raise?
+      defined?(Rails) && Rails.respond_to?(:env) && (Rails.env.development? || Rails.env.test?)
+    end
+
+    def studio_site_footer_report(error)
+      return if Studio::SiteFooterHelper.reported
+
+      Studio::SiteFooterHelper.reported = true
+      if defined?(::ErrorLog) && ::ErrorLog.respond_to?(:capture!)
+        ::ErrorLog.capture!(error)
+      elsif defined?(Rails.logger) && Rails.logger
+        Rails.logger.error("[studio.site_footer] #{error.class}: #{error.message}")
+      end
+    rescue StandardError
+      nil
+    end
+
+    class << self
+      attr_accessor :reported
+    end
+  end
+end

data/app/models/studio/site_identity.rb

@@ -33,7 +33,7 @@ module Studio
 
     # Read on EVERY page render (the head's tags), edited a few times a year. So
     # the stored values are cached, and busted on any write — see .stored.
-    CACHE_KEY_PREFIX = "studio/site_identity/v1"
+    CACHE_KEY_PREFIX = "studio/site_identity/v2" # v2: adds image_width/image_height
     CACHE_TTL = 1.hour
 
     TITLE_MAX = 200
@@ -194,12 +194,45 @@ module Studio
 
       def reset_static_image!
         @static_files = nil
+        @static_dimensions = nil
+      end
+
+      # [width, height] of the static fallback, read from the file's header, or
+      # nil when there is no local file (an absolute URL is never fetched) or its
+      # format is not one Studio::LinkPreview.image_dimensions reads. Memoized
+      # per path like static_image.
+      def static_image_dimensions
+        path = static_image
+        return nil if path.nil? || !path.start_with?("/") || path.start_with?("//")
+
+        @static_dimensions ||= Concurrent::Map.new
+        dims = @static_dimensions.compute_if_absent(path) do
+          Studio::LinkPreview.image_dimensions(Rails.public_path.join(path.delete_prefix("/"))) || false
+        end
+        dims || nil
+      end
+
+      # [width, height] from an attachment's or blob's ANALYZED metadata, or nil
+      # before Active Storage's analyze job has run (or for a non-image).
+      def image_dimensions(attachable)
+        return nil if attachable.nil?
+        return nil if attachable.respond_to?(:attached?) && !attachable.attached?
+
+        blob = attachable.respond_to?(:blob) ? attachable.blob : attachable
+        metadata = blob.respond_to?(:metadata) ? blob.metadata : nil
+        return nil unless metadata.is_a?(Hash)
+
+        width = metadata["width"] || metadata[:width]
+        height = metadata["height"] || metadata[:height]
+        width.is_a?(Integer) && height.is_a?(Integer) && width.positive? && height.positive? ? [width, height] : nil
+      rescue StandardError
+        nil
       end
 
       private
 
       def empty_stored
-        { title: nil, description: nil, image_url: nil, image_path: nil }
+        { title: nil, description: nil, image_url: nil, image_path: nil, image_width: nil, image_height: nil }
       end
 
       def compute_stored
@@ -207,11 +240,14 @@ module Studio
         return empty_stored if row.nil?
 
         location = row.respond_to?(:image) ? image_location(row.image) : nil
+        width, height = (image_dimensions(row.image) if location)
         {
           title: row.title.presence,
           description: row.description.presence,
           image_url: location&.dig(:url),
-          image_path: location&.dig(:path)
+          image_path: location&.dig(:path),
+          image_width: width,
+          image_height: height
         }
       end
     end

data/app/views/layouts/studio/_link_preview_tags.html.erb

@@ -3,7 +3,8 @@
     Studio::LinkPreviewHelper#studio_link_preview: the page override, else the
     operator default from /admin/link_preview, else the static fallback.
     Lifted from turf-monster's layouts/_link_preview_meta. og:image is absolute
-    and permanent; the tag is omitted rather than emitted empty. %>
+    and permanent; the tag is omitted rather than emitted empty. og:image:width
+    and og:image:height appear only when the image's size is known. %>
 <meta property="og:site_name" content="<%= preview[:site_name] %>">
 <meta property="og:type" content="website">
 <meta property="og:title" content="<%= preview[:title] %>">
@@ -15,6 +16,13 @@
 <% end %>
 <% if preview[:image] %>
 <meta property="og:image" content="<%= preview[:image] %>">
+<% if preview[:image_width] && preview[:image_height] %>
+<meta property="og:image:width" content="<%= preview[:image_width] %>">
+<meta property="og:image:height" content="<%= preview[:image_height] %>">
+<% end %>
+<% if preview[:image_alt] %>
+<meta property="og:image:alt" content="<%= preview[:image_alt] %>">
+<% end %>
 <% end %>
 <meta name="twitter:card" content="<%= preview[:image] ? "summary_large_image" : "summary" %>">
 <meta name="twitter:title" content="<%= preview[:title] %>">
@@ -23,4 +31,7 @@
 <% end %>
 <% if preview[:image] %>
 <meta name="twitter:image" content="<%= preview[:image] %>">
+<% if preview[:image_alt] %>
+<meta name="twitter:image:alt" content="<%= preview[:image_alt] %>">
+<% end %>
 <% end %>