journeybook 0.1.6.pre.alpha

data/app/services/journeybook/component_tag_updater.rb

@@ -0,0 +1,132 @@
+require "json"
+
+module Journeybook
+  class ComponentTagUpdater
+    def initialize(parser: ComponentParser.new)
+      @parser = parser
+    end
+
+    def update(markdown, index, props)
+      components = @parser.parse(markdown)
+      component = components.fetch(index)
+      replace_component(markdown, index, component.name, component.props.merge(normalized_props(props)))
+    end
+
+    def move(markdown, index, direction)
+      tags = component_tags(markdown)
+      tag = fetch_tag(tags, index)
+      target_index = direction.to_s == "up" ? index - 1 : index + 1
+      target = fetch_tag(tags, target_index)
+
+      replace_sources(markdown, {
+        tag => target.source,
+        target => tag.source
+      })
+    end
+
+    def reorder(markdown, indexes)
+      tags = component_tags(markdown)
+      indexes = Array(indexes).map(&:to_i)
+      raise ArgumentError unless indexes.sort == (0...tags.length).to_a
+
+      replace_sources(markdown, tags.zip(indexes.map { |index| tags.fetch(index).source }).to_h)
+    end
+
+    def delete(markdown, index)
+      tag = fetch_tag(component_tags(markdown), index)
+      replace_sources(markdown, tag => "").gsub(/\n{3,}/, "\n\n")
+    end
+
+    def toggle_visibility(markdown, index)
+      components = @parser.parse(markdown)
+      component = components.fetch(index)
+      props = component.props.dup
+
+      if component.hidden?
+        props.delete(ComponentParser::HIDDEN_PROP)
+      else
+        props[ComponentParser::HIDDEN_PROP] = "true"
+      end
+
+      replace_component(markdown, index, component.name, props)
+    end
+
+    def append(markdown, name, props = {})
+      source = serialize(name, normalized_props(props))
+      body = markdown.to_s.rstrip
+
+      return source if body.blank?
+
+      "#{body}\n\n#{source}"
+    end
+
+    private
+
+    ComponentTag = Data.define(:source, :begin_index, :end_index)
+
+    def fetch_tag(tags, index)
+      raise IndexError if index.negative? || index >= tags.length
+
+      tags.fetch(index)
+    end
+
+    def component_tags(markdown)
+      markdown.to_s.enum_for(:scan, ComponentParser::COMPONENT_PATTERN).map do
+        match = Regexp.last_match
+        ComponentTag.new(match[0], match.begin(0), match.end(0))
+      end
+    end
+
+    def replace_component(markdown, index, name, props)
+      updated_source = serialize(name, props)
+      current_index = -1
+
+      markdown.to_s.gsub(ComponentParser::COMPONENT_PATTERN) do |source|
+        current_index += 1
+        current_index == index ? updated_source : source
+      end
+    end
+
+    def replace_sources(markdown, replacements)
+      replacements.sort_by { |tag, _source| tag.begin_index }.reverse_each.reduce(markdown.to_s.dup) do |updated, (tag, source)|
+        updated[tag.begin_index...tag.end_index] = source
+        updated
+      end
+    end
+
+    def normalized_props(props)
+      props.to_h.each_with_object({}) do |(name, value), normalized|
+        normalized[name.to_sym] = parsed_collection(value) || value.to_s
+      end
+    end
+
+    def serialize(name, props)
+      serialized_props = props.map do |key, value|
+        %(#{key}=#{serialize_value(value)})
+      end
+
+      "{{ #{([ name ] + serialized_props).join(" ")} }}"
+    end
+
+    def escape_value(value)
+      value.to_s.gsub('"', "'")
+    end
+
+    def serialize_value(value)
+      collection = parsed_collection(value)
+      return %('#{JSON.generate(collection).gsub("'", "\\u0027")}') if collection
+
+      %("#{escape_value(value)}")
+    end
+
+    def parsed_collection(value)
+      return value if value.is_a?(Array) || value.is_a?(Hash)
+      return unless value.to_s.strip.start_with?("[", "{")
+
+      parsed = JSON.parse(value)
+      parsed if parsed.is_a?(Array) || parsed.is_a?(Hash)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/app/services/journeybook/component_validator.rb

@@ -0,0 +1,111 @@
+require "json"
+require "uri"
+
+module Journeybook
+  class ComponentValidator
+    def initialize(parser: ComponentParser.new, registry: Journeybook.components)
+      @parser = parser
+      @registry = registry
+    end
+
+    def errors_for(page)
+      components = @registry.for_site(page.site)
+
+      @parser.parse(page.markdown).flat_map.with_index do |component, index|
+        validate_component(component, index, components.registered(component.name))
+      end
+    end
+
+    private
+
+    def validate_component(component, index, registration)
+      label = "Component #{index + 1} (#{component.name})"
+      return [ "#{label} is not registered for this site." ] unless registration
+
+      schema = registration.normalized_props
+      props = component.props.except(ComponentParser::HIDDEN_PROP)
+      errors = props.keys.filter_map do |name|
+        "#{label} has an unknown prop: #{name}." unless schema.key?(name) || target_prop?(name, schema)
+      end
+
+      schema.each do |name, config|
+        value = props[name].to_s
+        errors << "#{label} is missing required prop: #{name}." if config[:required] && value.blank?
+        errors.concat(validate_collection(label, name, value, config)) if value.present? && config[:type] == :collection
+        errors << "#{label} has an invalid #{config[:type]} prop: #{name}." if value.present? && invalid_value?(value, config)
+      end
+
+      errors
+    end
+
+    def validate_collection(label, name, value, config)
+      items = JSON.parse(value)
+      return [ "#{label} has an invalid collection prop: #{name}." ] unless items.is_a?(Array)
+
+      errors = []
+      errors << "#{label} needs at least #{config[:min]} #{name} item(s)." if items.length < config[:min]
+      errors << "#{label} allows at most #{config[:max]} #{name} item(s)." if config[:max] && items.length > config[:max]
+
+      items.each_with_index do |item, index|
+        errors.concat(validate_collection_item(label, name, item, index, config[:item]))
+      end
+      errors
+    rescue JSON::ParserError
+      [ "#{label} has an invalid collection prop: #{name}." ]
+    end
+
+    def validate_collection_item(label, name, item, index, schema)
+      item_label = "#{label} #{name} item #{index + 1}"
+      return [ "#{item_label} must be an object." ] unless item.is_a?(Hash)
+
+      props = item.deep_symbolize_keys
+      errors = props.keys.filter_map do |key|
+        "#{item_label} has an unknown prop: #{key}." unless schema.key?(key) || target_prop?(key, schema)
+      end
+
+      schema.each do |key, config|
+        value = props[key].to_s
+        errors << "#{item_label} is missing required prop: #{key}." if config[:required] && value.blank?
+        errors << "#{item_label} has an invalid #{config[:type]} prop: #{key}." if value.present? && invalid_value?(value, config)
+      end
+      errors
+    end
+
+    def invalid_value?(value, config)
+      case config[:type]
+      when :select
+        !config[:options].include?(value)
+      when :image, :video
+        !http_url?(value) && !(config[:icons] && icon_reference?(value, config[:icons]))
+      when :url
+        !relative_or_http_url?(value) && !page_reference?(value)
+      else
+        false
+      end
+    end
+
+    def http_url?(value)
+      uri = URI.parse(value)
+      uri.is_a?(URI::HTTP) && uri.host.present?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def relative_or_http_url?(value)
+      value.start_with?("/", "#") || http_url?(value)
+    end
+
+    def page_reference?(value)
+      value.match?(%r{\Ajourneybook://page/\d+\z})
+    end
+
+    def icon_reference?(value, icon_config)
+      style, color, identifier = value.to_s.match(%r{\Aicon:([a-z0-9-]+):([a-z0-9-]+):([a-z0-9-]+)\z})&.captures
+      style.in?(icon_config[:styles]) && color.in?(icon_config[:colors]) && identifier.present?
+    end
+
+    def target_prop?(name, schema)
+      name.to_s.end_with?("_target") && schema.key?(name.to_s.delete_suffix("_target").to_sym)
+    end
+  end
+end

data/app/services/journeybook/form_mailer.rb

@@ -0,0 +1,69 @@
+module Journeybook
+  class FormMailer
+    class ConfigurationError < StandardError; end
+
+    DEFAULT_SUBJECT = "New Journeybook form submission".freeze
+
+    def initialize(client: nil, configuration: Journeybook.configuration)
+      @client = client
+      @configuration = configuration
+    end
+
+    def deliver(fields:)
+      validate_configuration!
+
+      client.send_email(
+        from: @configuration.form_from,
+        to: @configuration.form_to,
+        subject: fields.delete("subject").to_s.truncate(200).presence || DEFAULT_SUBJECT,
+        text_body: body_for(fields),
+        reply_to: reply_to_for(fields)
+      )
+    end
+
+    private
+
+    def client
+      @client ||= delivery_client
+    end
+
+    def delivery_client
+      case delivery_method
+      when "postmark"
+        PostmarkClient.new(api_key: @configuration.postmark_api_key)
+      when "letter_opener"
+        LetterOpenerClient.new
+      else
+        raise ConfigurationError, "Unsupported Journeybook form delivery method: #{delivery_method}"
+      end
+    end
+
+    def delivery_method
+      @configuration.form_delivery_method.to_s
+    end
+
+    def validate_configuration!
+      missing = []
+      missing << "postmark_api_key" if delivery_method == "postmark" && @configuration.postmark_api_key.blank?
+      missing << "form_from" if @configuration.form_from.blank?
+      missing << "form_to" if @configuration.form_to.blank?
+      return if missing.empty?
+
+      raise ConfigurationError, "Missing Journeybook email configuration: #{missing.join(", ")}"
+    end
+
+    def body_for(fields)
+      fields.map do |name, value|
+        "#{name.to_s.humanize}: #{format_value(value)}"
+      end.join("\n\n")
+    end
+
+    def format_value(value)
+      Array(value).join(", ")
+    end
+
+    def reply_to_for(fields)
+      fields["email"].presence
+    end
+  end
+end

data/app/services/journeybook/html_sanitizer.rb

@@ -0,0 +1,46 @@
+module Journeybook
+  class HtmlSanitizer
+    ALLOWED_TAGS = %w[
+      a abbr article blockquote br button code dd div dl dt em figcaption figure form h1 h2 h3 h4 h5 h6 i
+      hr iframe img input kbd label li ol p pre span strong table tbody td textarea th thead tr ul
+      section
+    ].freeze
+
+    ALLOWED_ATTRIBUTES = %w[
+      action allow allowfullscreen alt autocomplete class height href id loading method name placeholder referrerpolicy rel required rows src target title type value width
+    ].freeze
+
+    ALLOWED_IFRAME_HOSTS = %w[
+      www.youtube.com youtube.com www.youtube-nocookie.com youtube-nocookie.com player.vimeo.com
+    ].freeze
+
+    # @param html [String]
+    # @return [String]
+    def sanitize(html)
+      remove_unsafe_iframes(sanitizer.sanitize(html.to_s, tags: ALLOWED_TAGS, attributes: ALLOWED_ATTRIBUTES).to_s)
+    end
+
+    private
+
+    def remove_unsafe_iframes(html)
+      fragment = Nokogiri::HTML5.fragment(html)
+
+      fragment.css("iframe").each do |iframe|
+        iframe.remove unless safe_iframe_src?(iframe["src"])
+      end
+
+      fragment.to_html
+    end
+
+    def safe_iframe_src?(src)
+      uri = URI.parse(src.to_s)
+      uri.is_a?(URI::HTTPS) && ALLOWED_IFRAME_HOSTS.include?(uri.host.to_s.downcase)
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def sanitizer
+      @sanitizer ||= Rails::HTML5::SafeListSanitizer.new
+    end
+  end
+end

data/app/services/journeybook/letter_opener_client.rb

@@ -0,0 +1,14 @@
+module Journeybook
+  class LetterOpenerClient
+    def send_email(from:, to:, subject:, text_body:, reply_to: nil)
+      require "letter_opener"
+
+      message = Mail.new(from:, to:, subject:, body: text_body)
+      message.reply_to = reply_to if reply_to.present?
+      message.delivery_method(LetterOpener::DeliveryMethod, location: Rails.root.join("tmp/letter_opener"))
+      message.deliver!
+    rescue LoadError
+      raise FormMailer::ConfigurationError, "Install the letter_opener gem to use Journeybook form_delivery_method = :letter_opener"
+    end
+  end
+end

data/app/services/journeybook/markdown_renderer.rb

@@ -0,0 +1,29 @@
+require "commonmarker"
+
+module Journeybook
+  class MarkdownRenderer
+    # @param markdown [String]
+    # @return [String]
+    def render(markdown)
+      Commonmarker.to_html(markdown.to_s, options: commonmarker_options)
+    rescue ArgumentError
+      Commonmarker.to_html(markdown.to_s)
+    end
+
+    private
+
+    def commonmarker_options
+      {
+        extension: {
+          table: true,
+          strikethrough: true,
+          autolink: true,
+          tasklist: true
+        },
+        render: {
+          unsafe: true
+        }
+      }
+    end
+  end
+end

data/app/services/journeybook/page_renderer.rb

@@ -0,0 +1,58 @@
+module Journeybook
+  class PageRenderer
+    def initialize(
+      parser: ComponentParser.new,
+      markdown_renderer: MarkdownRenderer.new,
+      component_renderer: ComponentRenderer.new,
+      sanitizer: HtmlSanitizer.new
+    )
+      @parser = parser
+      @markdown_renderer = markdown_renderer
+      @component_renderer = component_renderer
+      @sanitizer = sanitizer
+    end
+
+    # @param page_or_markdown [Journeybook::Page, String]
+    # @return [String]
+    def render(page_or_markdown, form_authenticity_token: nil, component_index: nil, component_anchors: false)
+      @component_anchors = component_anchors
+      markdown = page_or_markdown.respond_to?(:markdown) ? page_or_markdown.markdown : page_or_markdown
+      extracted_markdown, components = @parser.extract(markdown)
+        return render_component(components[component_index], form_authenticity_token, page_or_markdown) if component_index
+
+        page = page_or_markdown if page_or_markdown.respond_to?(:markdown)
+        html = @markdown_renderer.render(extracted_markdown)
+
+      components.each_with_index do |component, index|
+        html = html.gsub(%r{<p>\s*#{component.token}\s*</p>}, component.token)
+          html = html.gsub(component.token, "#{component_anchor(index)}#{@component_renderer.render(component, page:)}")
+      end
+
+      @sanitizer.sanitize(inject_form_token(html, form_authenticity_token))
+    end
+
+    private
+
+      def render_component(component, form_authenticity_token, page)
+      return "" unless component
+
+        @sanitizer.sanitize(inject_form_token(@component_renderer.render(component, page:), form_authenticity_token))
+    end
+
+    def component_anchor(index)
+      return "" unless @component_anchors
+
+      %(<span id="journeybook-preview-component-#{index}" data-journeybook-preview-component="#{index}"></span>)
+    end
+
+    def inject_form_token(html, token)
+      return html if token.blank?
+
+      action = Regexp.escape(Journeybook.configuration.form_action.to_s)
+      form = %r{(<form\b(?=[^>]*\baction=(["'])#{action}\2)[^>]*>)}
+      token_input = %(<input type="hidden" name="authenticity_token" value="#{ERB::Util.html_escape(token)}">)
+
+      html.gsub(form) { "#{Regexp.last_match(1)}#{token_input}" }
+    end
+  end
+end

data/app/services/journeybook/page_resolver.rb

@@ -0,0 +1,55 @@
+module Journeybook
+  class PageResolver
+    def self.from_request(request, path: nil, locale: nil)
+      new(host: request.host, path: path, locale: locale)
+    end
+
+    def initialize(host:, path:, locale: nil)
+      @host = host
+      @path = path
+      @locale = locale
+    end
+
+    def call
+      matched_site = site
+      return unless matched_site
+
+      pages = matched_site.pages.published.by_path(matched_site.relative_path_for(normalized_path))
+      pages = pages.where(locale: @locale) if @locale.present?
+      pages.first
+    end
+
+    def site
+      @site ||= find_site
+    end
+
+    private
+
+    def find_site
+      sites = matching_host_sites.presence || local_sites
+      sites.by_longest_prefix.detect { |site| site.matches_path?(normalized_path) }
+    end
+
+    def matching_host_sites
+      Site.for_host(@host)
+    end
+
+    def local_sites
+      return Site.none unless local_host?
+
+      Site.where(host: %w[localhost 127.0.0.1])
+    end
+
+    def local_host?
+      @host.in?(%w[localhost 127.0.0.1 0.0.0.0])
+    end
+
+    def normalized_path
+      path = @path.to_s.strip
+      path = "/#{path}" unless path.start_with?("/")
+      path = path.squeeze("/")
+      path = path.delete_suffix("/") unless path == "/"
+      path.presence || "/"
+    end
+  end
+end

data/app/services/journeybook/postmark_client.rb

@@ -0,0 +1,48 @@
+require "json"
+require "net/http"
+require "uri"
+
+module Journeybook
+  class PostmarkClient
+    class Error < StandardError; end
+
+    ENDPOINT = URI("https://api.postmarkapp.com/email")
+
+    def initialize(api_key: Journeybook.configuration.postmark_api_key, endpoint: ENDPOINT)
+      @api_key = api_key
+      @endpoint = endpoint
+    end
+
+    def send_email(from:, to:, subject:, text_body:, reply_to: nil)
+      response = Net::HTTP.start(@endpoint.host, @endpoint.port, use_ssl: @endpoint.scheme == "https") do |http|
+        http.request(request(from:, to:, subject:, text_body:, reply_to:))
+      end
+
+      return response if response.is_a?(Net::HTTPSuccess)
+
+      raise Error, "Postmark delivery failed: #{response.code} #{response.body}"
+    end
+
+    private
+
+    def request(from:, to:, subject:, text_body:, reply_to:)
+      request = Net::HTTP::Post.new(@endpoint)
+      request["Accept"] = "application/json"
+      request["Content-Type"] = "application/json"
+      request["X-Postmark-Server-Token"] = @api_key.to_s
+      request.body = payload(from:, to:, subject:, text_body:, reply_to:).to_json
+      request
+    end
+
+    def payload(from:, to:, subject:, text_body:, reply_to:)
+      {
+        From: from,
+        To: to,
+        Subject: subject,
+        TextBody: text_body
+      }.tap do |attributes|
+        attributes[:ReplyTo] = reply_to if reply_to.present?
+      end
+    end
+  end
+end

data/app/services/journeybook/storage/s3_client.rb

@@ -0,0 +1,96 @@
+require "aws-sdk-s3"
+require "digest"
+require "securerandom"
+
+module Journeybook
+  module Storage
+    class S3Client
+      class Error < Journeybook::Error; end
+
+      Upload = Data.define(:storage_key, :original_filename, :content_type, :byte_size, :checksum)
+
+      def initialize(configuration: Journeybook.configuration, client: nil)
+        @configuration = configuration
+        @client = client
+      end
+
+      def upload(file)
+        raise Error, "Image file is required." unless file.respond_to?(:read)
+
+        content = file.read
+        file.rewind if file.respond_to?(:rewind)
+        original_filename = File.basename(file.original_filename.to_s)
+        content_type = file.content_type.to_s
+        storage_key = build_storage_key(original_filename)
+
+        s3_client.put_object(
+          bucket: bucket,
+          key: storage_key,
+          body: content,
+          content_type: content_type
+        )
+
+        Upload.new(
+          storage_key: storage_key,
+          original_filename: original_filename,
+          content_type: content_type,
+          byte_size: content.bytesize,
+          checksum: Digest::SHA256.hexdigest(content)
+        )
+      end
+
+      def delete(storage_key)
+        return if storage_key.blank?
+
+        s3_client.delete_object(bucket: bucket, key: storage_key)
+      end
+
+      def public_url(storage_key)
+        base_url = @configuration.s3_public_base_url.to_s.delete_suffix("/")
+        return "#{base_url}/#{storage_key}" if base_url.present?
+
+        raise Error, "Journeybook S3 bucket and region are required." if bucket.blank? || region.blank?
+
+        "https://#{bucket}.s3.#{region}.amazonaws.com/#{storage_key}"
+      end
+
+      private
+
+      def s3_client
+        @client ||= begin
+          raise Error, "Journeybook S3 bucket is missing. Set config.s3_bucket." if bucket.blank?
+          raise Error, "Journeybook S3 region is missing. Set config.s3_region." if region.blank?
+          raise Error, "Journeybook S3 access key is missing. Set config.s3_access_key_id." if @configuration.s3_access_key_id.blank?
+          raise Error, "Journeybook S3 secret key is missing. Set config.s3_secret_access_key." if @configuration.s3_secret_access_key.blank?
+
+          Aws::S3::Client.new(
+            region: region,
+            access_key_id: @configuration.s3_access_key_id,
+            secret_access_key: @configuration.s3_secret_access_key
+          )
+        end
+      end
+
+      def build_storage_key(original_filename)
+        filename = sanitize_filename(original_filename.presence || "image")
+        [ prefix, "media", SecureRandom.uuid, filename ].reject(&:blank?).join("/")
+      end
+
+      def sanitize_filename(filename)
+        filename.to_s.downcase.gsub(/[^a-z0-9.\-_]+/, "-").delete_prefix("-").delete_suffix("-").presence || "image"
+      end
+
+      def prefix
+        @configuration.s3_prefix.to_s.strip.delete_prefix("/").delete_suffix("/")
+      end
+
+      def bucket
+        @configuration.s3_bucket
+      end
+
+      def region
+        @configuration.s3_region
+      end
+    end
+  end
+end