not_pressed-core 0.1.0

data/lib/not_pressed/plugin_packager.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "zip"
+require "json"
+
+module NotPressed
+  # Exports a registered plugin into a distributable zip archive.
+  #
+  # The archive contains a manifest.json with plugin metadata and all
+  # associated source files (plugin class file and editor partials).
+  #
+  # @example
+  #   packager = NotPressed::PluginPackager.new("Analytics")
+  #   zip_path = packager.package("/tmp/exports")
+  class PluginPackager
+    # @param plugin_name [String] the registered plugin name
+    def initialize(plugin_name)
+      @plugin_name = plugin_name
+    end
+
+    # Creates a zip archive of the plugin at the given output directory.
+    #
+    # @param output_path [String] directory where the zip will be written
+    # @return [String] absolute path to the created zip file
+    # @raise [PluginManager::NotFound] if the plugin is not registered
+    # @raise [ArgumentError] if output_path does not exist
+    def package(output_path)
+      entry = PluginManager.find(@plugin_name)
+      klass = entry[:klass]
+
+      raise ArgumentError, "Output directory does not exist: #{output_path}" unless Dir.exist?(output_path)
+
+      files = collect_files(klass)
+      manifest = build_manifest(klass, files)
+
+      zip_filename = "#{snake_name(klass)}-#{klass.plugin_version || '0.0.0'}.zip"
+      zip_path = File.join(output_path, zip_filename)
+
+      root = engine_root
+
+      Zip::File.open(zip_path, create: true) do |zip|
+        zip.get_output_stream("manifest.json") { |io| io.write(JSON.pretty_generate(manifest)) }
+
+        files.each do |relative_path|
+          absolute = File.join(root, relative_path)
+          zip.add(relative_path, absolute) if File.exist?(absolute)
+        end
+      end
+
+      zip_path
+    end
+
+    private
+
+    # Collects all files that belong to the plugin.
+    #
+    # @param klass [Class] the plugin class
+    # @return [Array<String>] relative file paths from engine root
+    def collect_files(klass)
+      files = []
+      root = engine_root
+
+      # Plugin class file
+      plugin_file = "app/plugins/not_pressed/#{snake_name(klass)}_plugin.rb"
+      files << plugin_file if File.exist?(File.join(root, plugin_file))
+
+      # Editor partials for each block type
+      klass.plugin_block_types.each do |bt|
+        bt_name = bt[:name].to_s
+        pattern = File.join(root, "app/views/not_pressed/admin/content_blocks/editors/*#{bt_name}*")
+        Dir.glob(pattern).each do |path|
+          relative = path.sub("#{root}/", "").tr("\\", "/")
+          files << relative
+        end
+      end
+
+      files
+    end
+
+    # Builds the manifest hash from plugin DSL metadata.
+    #
+    # @param klass [Class] the plugin class
+    # @param files [Array<String>] list of files included in the archive
+    # @return [Hash] manifest data
+    def build_manifest(klass, files)
+      {
+        name: klass.plugin_name,
+        version: klass.plugin_version,
+        description: klass.plugin_description,
+        author: klass.plugin_author,
+        url: klass.plugin_url,
+        dependencies: (klass.plugin_dependencies || []).map { |d| { name: d[:name], constraint: d[:constraint] } },
+        settings_schema: (klass.plugin_settings_schema || []).map { |s| stringify_keys(s) },
+        block_types: (klass.plugin_block_types || []).map { |bt| { name: bt[:name].to_s, options: stringify_keys(bt[:options]) } },
+        files: files
+      }
+    end
+
+    # Converts a plugin class to its snake_case file name stem.
+    #
+    # @param klass [Class] the plugin class
+    # @return [String] snake_case name
+    def snake_name(klass)
+      # Use Module#name directly to bypass the Plugin DSL `name` override
+      Module.instance_method(:name).bind_call(klass).split("::").last
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .downcase
+        .sub(/_plugin$/, "")
+    end
+
+    # Returns the engine root directory.
+    #
+    # @return [String]
+    def engine_root
+      NotPressed::Engine.root.to_s
+    end
+
+    # Deep-converts symbol keys to strings for JSON serialization.
+    #
+    # @param hash [Hash] input hash
+    # @return [Hash] hash with string keys
+    def stringify_keys(hash)
+      hash.each_with_object({}) do |(k, v), h|
+        h[k.to_s] = v.is_a?(Hash) ? stringify_keys(v) : v
+      end
+    end
+  end
+end

data/lib/not_pressed/rendering/block_renderer.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "action_view"
+
+module NotPressed
+  module Rendering
+    # Renders individual content blocks and full pages to HTML.
+    #
+    # Delegates to {RendererRegistry} for type-specific rendering and applies
+    # hook filters before and after rendering.
+    class BlockRenderer
+      ALLOWED_TEXT_TAGS = %w[p br strong em a ul ol li h1 h2 h3 h4 h5 h6 span div].freeze
+      ALLOWED_TEXT_ATTRIBUTES = %w[href target rel class id].freeze
+
+      YOUTUBE_REGEX = %r{(?:youtube\.com/watch\?v=|youtu\.be/|youtube\.com/embed/)([\w-]+)}
+      VIMEO_REGEX = %r{(?:vimeo\.com/)(\d+)}
+
+      class << self
+        # Renders a single content block to HTML.
+        #
+        # Applies the +:block_content_before_render+ filter to the content hash
+        # and the +:block_content_after_render+ filter to the rendered HTML.
+        #
+        # @param block [NotPressed::ContentBlock] the content block to render
+        # @return [ActiveSupport::SafeBuffer] rendered HTML
+        def render(block)
+          content = NotPressed::Hooks.apply_filter(:block_content_before_render, (block.content || {}).dup, block)
+          html = render_by_type(block.block_type.to_s, content, block)
+          html = NotPressed::Hooks.apply_filter(:block_content_after_render, html, block)
+          html.html_safe
+        end
+
+        # Renders all ordered content blocks for a page.
+        #
+        # Applies the +:page_content+ filter to the combined HTML output.
+        #
+        # @param page [NotPressed::Page] the page whose blocks to render
+        # @return [ActiveSupport::SafeBuffer] rendered HTML (empty string if no blocks)
+        def render_page(page)
+          blocks = page.content_blocks.ordered
+          return "".html_safe if blocks.empty?
+
+          html = blocks.map { |block| render(block) }.join("\n")
+          html = NotPressed::Hooks.apply_filter(:page_content, html, page)
+          html.html_safe
+        end
+
+        private
+
+        def render_by_type(block_type, content, block)
+          RendererRegistry.render(block_type, content, block)
+        end
+
+        def render_text(content)
+          body = sanitize_html(content["body"].to_s)
+          %(<div class="np-content-text">#{body}</div>)
+        end
+
+        def render_heading(content)
+          text = escape(content["text"].to_s)
+          level = content["level"].to_i
+          level = 2 unless (1..6).cover?(level)
+          %(<h#{level} class="np-content-heading">#{text}</h#{level}>)
+        end
+
+        def render_image(content)
+          url = resolve_image_url(content)
+          alt = escape(content["alt"].to_s)
+          caption = content["caption"].to_s.strip
+
+          html = %(<figure class="np-content-image"><img src="#{escape(url)}" alt="#{alt}">)
+          html += %(<figcaption>#{escape(caption)}</figcaption>) unless caption.empty?
+          html += %(</figure>)
+          html
+        end
+
+        def resolve_image_url(content)
+          if content["media_id"].present?
+            media = NotPressed::MediaAttachment.find_by(id: content["media_id"])
+            if media&.file&.attached?
+              return Rails.application.routes.url_helpers.rails_blob_path(media.file, disposition: "inline", only_path: true)
+            end
+          end
+
+          content["url"].to_s
+        end
+
+        def render_video(content)
+          url = content["url"].to_s
+          caption = content["caption"].to_s.strip
+
+          html = %(<div class="np-content-video">)
+
+          if (match = url.match(YOUTUBE_REGEX))
+            video_id = match[1]
+            html += %(<iframe src="https://www.youtube.com/embed/#{video_id}" frameborder="0" allowfullscreen></iframe>)
+          elsif (match = url.match(VIMEO_REGEX))
+            video_id = match[1]
+            html += %(<iframe src="https://player.vimeo.com/video/#{video_id}" frameborder="0" allowfullscreen></iframe>)
+          else
+            html += %(<video src="#{escape(url)}" controls></video>)
+          end
+
+          html += %(<figcaption>#{escape(caption)}</figcaption>) unless caption.empty?
+          html += %(</div>)
+          html
+        end
+
+        def render_code(content)
+          code = escape(content["code"].to_s)
+          language = content["language"].to_s.strip
+          lang_class = language.empty? ? "" : %( class="language-#{escape(language)}")
+          %(<pre class="np-content-code"><code#{lang_class}>#{code}</code></pre>)
+        end
+
+        def render_quote(content)
+          text = escape(content["text"].to_s)
+          attribution = content["attribution"].to_s.strip
+
+          html = %(<blockquote class="np-content-quote"><p>#{text}</p>)
+          html += %(<cite>#{escape(attribution)}</cite>) unless attribution.empty?
+          html += %(</blockquote>)
+          html
+        end
+
+        def render_divider
+          %(<hr class="np-content-divider">)
+        end
+
+        def render_html(content)
+          markup = content["markup"].to_s
+          %(<div class="np-content-html">#{markup}</div>)
+        end
+
+        def render_form_block(content)
+          form_id = content["form_id"]
+          return %(<div class="np-content-form"></div>) unless form_id
+
+          form = NotPressed::Form.find_by(id: form_id)
+          return %(<div class="np-content-form">Form not found</div>) unless form&.status_active?
+
+          action_url = NotPressed::Engine.routes.url_helpers.form_submissions_path(form_slug: form.slug)
+          fields_html = form.form_fields.ordered.map { |field| render_form_field_html(field) }.join("\n")
+
+          form_html = %(<form action="#{action_url}" method="post" class="np-public-form">
+#{fields_html}
+<div class="np-form-submit"><input type="submit" value="Submit" class="np-form-submit-btn"></div>
+</form>)
+
+          %(<div class="np-content-form">#{form_html}</div>)
+        end
+
+        def render_form_field_html(field)
+          fname = escape(field.label.parameterize(separator: "_"))
+          fid = "field_#{field.id}"
+          req = field.required? ? ' required="required"' : ""
+          placeholder = escape(field.placeholder.to_s)
+
+          input_html = case field.field_type.to_s
+                       when "text", "email", "number", "url", "date"
+                         %(<input type="#{field.field_type}" name="submission[#{fname}]" id="#{fid}" class="np-form-input" placeholder="#{placeholder}"#{req}>)
+                       when "phone"
+                         %(<input type="tel" name="submission[#{fname}]" id="#{fid}" class="np-form-input" placeholder="#{placeholder}"#{req}>)
+                       when "textarea"
+                         %(<textarea name="submission[#{fname}]" id="#{fid}" class="np-form-input" placeholder="#{placeholder}" rows="4"#{req}></textarea>)
+                       when "select"
+                         options = (field.options || "").split("\n").map(&:strip).reject(&:blank?)
+                         opts = %(<option value="">Select...</option>) + options.map { |o| %(<option value="#{escape(o)}">#{escape(o)}</option>) }.join
+                         %(<select name="submission[#{fname}]" id="#{fid}" class="np-form-input"#{req}>#{opts}</select>)
+                       when "radio"
+                         options = (field.options || "").split("\n").map(&:strip).reject(&:blank?)
+                         options.map { |o| %(<label class="np-form-radio-label"><input type="radio" name="submission[#{fname}]" value="#{escape(o)}"#{req}> #{escape(o)}</label>) }.join("\n")
+                       when "checkbox"
+                         options = (field.options || "").split("\n").map(&:strip).reject(&:blank?)
+                         if options.any?
+                           options.map { |o| %(<label class="np-form-checkbox-label"><input type="checkbox" name="submission[#{fname}][]" value="#{escape(o)}"> #{escape(o)}</label>) }.join("\n")
+                         else
+                           %(<input type="checkbox" name="submission[#{fname}]" id="#{fid}" value="1"#{req}>)
+                         end
+                       when "file_upload"
+                         %(<input type="file" name="submission[#{fname}]" id="#{fid}" class="np-form-input"#{req}>)
+                       else
+                         %(<input type="text" name="submission[#{fname}]" id="#{fid}" class="np-form-input"#{req}>)
+                       end
+
+          %(<div class="np-form-field">
+<label class="np-form-label" for="#{fid}">#{escape(field.label)}#{" *" if field.required?}</label>
+#{input_html}
+</div>)
+        end
+
+        def render_unknown(block_type)
+          %(<div class="np-content-unknown">Unknown block type: #{escape(block_type.to_s)}</div>)
+        end
+
+        def register_built_in_renderers
+          %w[text heading image video code quote html].each do |type|
+            method_ref = method(:"render_#{type}")
+            RendererRegistry.register_built_in(type, ->(content, _block) { method_ref.call(content) })
+          end
+          RendererRegistry.register_built_in("divider", ->(_content, _block) { render_divider })
+          RendererRegistry.register_built_in("form", ->(content, _block) { render_form_block(content) })
+        end
+
+        def escape(text)
+          ERB::Util.html_escape(text)
+        end
+
+        def sanitize_html(html)
+          ActionView::Base.safe_list_sanitizer.sanitize(
+            html,
+            tags: ALLOWED_TEXT_TAGS,
+            attributes: ALLOWED_TEXT_ATTRIBUTES
+          )
+        end
+      end
+
+      # Register built-in renderers at load time
+      register_built_in_renderers
+    end
+  end
+end

data/lib/not_pressed/rendering/renderer_registry.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Rendering
+    # Registry for custom and built-in block type renderers, editor partials,
+    # and default content.
+    #
+    # Custom renderers take priority over built-in renderers. Each renderer
+    # must respond to +#call(content, block_record)+.
+    #
+    # @example Registering a custom renderer
+    #   RendererRegistry.register("gallery") do |content, block|
+    #     "<div class='gallery'>#{content['images'].size} images</div>"
+    #   end
+    class RendererRegistry
+      class << self
+        # Registers a custom renderer for a block type.
+        #
+        # Custom renderers take priority over built-in renderers.
+        #
+        # @param block_type [String, Symbol] block type identifier
+        # @param renderer [#call, nil] callable renderer, or pass a block instead
+        # @yield [content, block_record] alternative to the renderer parameter
+        # @raise [ArgumentError] if the renderer does not respond to +#call+
+        # @return [void]
+        def register(block_type, renderer = nil, &block)
+          renderer = block if block_given?
+          raise ArgumentError, "Renderer must respond to #call" unless renderer.respond_to?(:call)
+
+          custom_renderers[block_type.to_s] = renderer
+        end
+
+        # Renders a block using the appropriate renderer.
+        #
+        # Looks up custom renderers first, then built-in, then falls back
+        # to a generic "unknown type" message.
+        #
+        # @param block_type [String] block type identifier
+        # @param content [Hash] block content data
+        # @param block_record [NotPressed::ContentBlock] the content block record
+        # @return [String] rendered HTML
+        def render(block_type, content, block_record)
+          type = block_type.to_s
+          renderer = custom_renderers[type] || built_in_renderers[type]
+
+          if renderer
+            renderer.call(content, block_record)
+          else
+            render_fallback(type, content)
+          end
+        end
+
+        # Checks whether a renderer exists for the block type.
+        #
+        # @param block_type [String, Symbol] block type identifier
+        # @return [Boolean]
+        def registered?(block_type)
+          type = block_type.to_s
+          custom_renderers.key?(type) || built_in_renderers.key?(type)
+        end
+
+        # Clears all custom renderers, editor partials, and default content.
+        #
+        # @return [void]
+        def reset!
+          custom_renderers.clear
+          editor_partials.clear
+          default_contents.clear
+        end
+
+        # Removes the custom renderer, editor partial, and default content
+        # for a block type.
+        #
+        # @param block_type [String, Symbol] block type identifier
+        # @return [void]
+        def unregister(block_type)
+          type = block_type.to_s
+          custom_renderers.delete(type)
+          editor_partials.delete(type)
+          default_contents.delete(type)
+        end
+
+        # Registers a built-in renderer (lower priority than custom renderers).
+        #
+        # @param block_type [String] block type identifier
+        # @param renderer [#call] callable renderer
+        # @return [void]
+        def register_built_in(block_type, renderer)
+          built_in_renderers[block_type.to_s] = renderer
+        end
+
+        # Registers a custom editor partial path for a block type.
+        #
+        # @param block_type [String, Symbol] block type identifier
+        # @param partial_path [String] path to the editor partial
+        # @return [void]
+        def register_editor(block_type, partial_path)
+          editor_partials[block_type.to_s] = partial_path
+        end
+
+        # Returns the editor partial path for a block type.
+        #
+        # Falls back to +not_pressed/admin/content_blocks/editors/<type>+.
+        #
+        # @param block_type [String, Symbol] block type identifier
+        # @return [String] partial path
+        def editor_partial(block_type)
+          type = block_type.to_s
+          editor_partials[type] || "not_pressed/admin/content_blocks/editors/#{type}"
+        end
+
+        # Registers default content for new blocks of the given type.
+        #
+        # @param block_type [String, Symbol] block type identifier
+        # @param content_hash [Hash] default content structure
+        # @return [void]
+        def register_default_content(block_type, content_hash)
+          default_contents[block_type.to_s] = content_hash
+        end
+
+        # Returns the default content hash for a block type.
+        #
+        # @param block_type [String, Symbol] block type identifier
+        # @return [Hash, nil] the default content, or nil if none registered
+        def default_content(block_type)
+          default_contents[block_type.to_s]
+        end
+
+        private
+
+        def custom_renderers
+          @custom_renderers ||= {}
+        end
+
+        def built_in_renderers
+          @built_in_renderers ||= {}
+        end
+
+        def editor_partials
+          @editor_partials ||= {}
+        end
+
+        def default_contents
+          @default_contents ||= {}
+        end
+
+        def render_fallback(block_type, _content)
+          escaped_type = ERB::Util.html_escape(block_type)
+          %(<div class="np-content-unknown">Unknown block type: #{escaped_type}</div>)
+        end
+      end
+    end
+  end
+end

data/lib/not_pressed/rendering.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Rendering
+  end
+end
+
+require_relative "rendering/renderer_registry"

data/lib/not_pressed/seo/sitemap_builder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module NotPressed
+  module Seo
+    class SitemapBuilder
+      XMLNS = "http://www.sitemaps.org/schemas/sitemap/0.9"
+
+      def initialize(base_url:)
+        @base_url = base_url.chomp("/")
+      end
+
+      def generate
+        pages = NotPressed::Page.visible.publicly_accessible.includes(:parent)
+
+        urls = pages.map { |page| url_entry(page) }.join
+
+        %(<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="#{XMLNS}">\n#{urls}</urlset>\n)
+      end
+
+      private
+
+      def url_entry(page)
+        loc = CGI.escapeHTML("#{@base_url}/#{page.slug}")
+        lastmod = page.updated_at.iso8601
+        priority = priority_for(page)
+
+        "  <url>\n" \
+          "    <loc>#{loc}</loc>\n" \
+          "    <lastmod>#{lastmod}</lastmod>\n" \
+          "    <changefreq>weekly</changefreq>\n" \
+          "    <priority>#{priority}</priority>\n" \
+          "  </url>\n"
+      end
+
+      def priority_for(page)
+        depth = compute_depth(page)
+
+        case depth
+        when 0 then "1.0"
+        when 1 then "0.8"
+        when 2 then "0.6"
+        else "0.5"
+        end
+      end
+
+      def compute_depth(page)
+        depth = 0
+        current = page
+
+        while current.parent_id.present?
+          depth += 1
+          current = current.parent
+        end
+
+        depth
+      end
+    end
+  end
+end