not_pressed-core 0.1.0

data/app/controllers/not_pressed/robots_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class RobotsController < ApplicationController
+    def show
+      render plain: robots_content, content_type: "text/plain"
+    end
+
+    private
+
+    def robots_content
+      custom = NotPressed.configuration.robots_txt
+
+      case custom
+      when Proc
+        custom.call(request)
+      when String
+        custom
+      else
+        default_robots_content
+      end
+    end
+
+    def default_robots_content
+      sitemap_url = not_pressed.sitemap_url(host: request.host, port: request.port, protocol: request.protocol)
+
+      <<~ROBOTS
+        User-agent: *
+        Allow: /
+        Sitemap: #{sitemap_url}
+      ROBOTS
+    end
+  end
+end

data/app/controllers/not_pressed/sitemaps_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class SitemapsController < ApplicationController
+    def show
+      expires_in 1.hour, public: true
+
+      builder = NotPressed::Seo::SitemapBuilder.new(base_url: root_url)
+      render xml: builder.generate
+    end
+  end
+end

data/app/helpers/not_pressed/admin_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module AdminHelper
+    def admin_breadcrumb(label, path = nil)
+      @breadcrumbs ||= []
+      @breadcrumbs << { label: label, path: path }
+    end
+
+    def status_badge(status)
+      content_tag(:span, status.to_s.humanize, class: "np-badge np-badge--#{status}")
+    end
+
+    def admin_nav_item(label, path, icon: nil)
+      css_class = current_page?(path) ? "np-nav-active" : nil
+      link_to label, path, class: css_class
+    end
+
+    def time_ago_short(time)
+      return "" if time.nil?
+
+      seconds = (Time.current - time).to_i
+      minutes = seconds / 60
+      hours = minutes / 60
+      days = hours / 24
+      weeks = days / 7
+
+      if seconds < 60
+        "#{seconds}s ago"
+      elsif minutes < 60
+        "#{minutes}m ago"
+      elsif hours < 24
+        "#{hours}h ago"
+      elsif days < 7
+        "#{days}d ago"
+      else
+        "#{weeks}w ago"
+      end
+    end
+  end
+end

data/app/helpers/not_pressed/application_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module ApplicationHelper
+  end
+end

data/app/helpers/not_pressed/code_injection_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module CodeInjectionHelper
+    def head_injection(page = nil)
+      parts = []
+
+      global = NotPressed.configuration.global_head_code
+      global = NotPressed::Setting.get("global_head_code") if global.nil? && defined?(NotPressed::Setting)
+      parts << global if global.present?
+
+      parts << page.head_code if page&.head_code.present?
+
+      parts.join("\n").html_safe
+    end
+
+    def body_injection(page = nil)
+      parts = []
+
+      global = NotPressed.configuration.global_body_code
+      global = NotPressed::Setting.get("global_body_code") if global.nil? && defined?(NotPressed::Setting)
+      parts << global if global.present?
+
+      parts << page.body_code if page&.body_code.present?
+
+      parts.join("\n").html_safe
+    end
+  end
+end

data/app/helpers/not_pressed/content_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module ContentHelper
+    def render_page_content(page)
+      NotPressed::Rendering::BlockRenderer.render_page(page)
+    end
+
+    def render_block(block)
+      NotPressed::Rendering::BlockRenderer.render(block)
+    end
+  end
+end

data/app/helpers/not_pressed/form_helper.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module FormHelper
+    def render_form(form)
+      return "" unless form
+
+      fields_html = form.form_fields.ordered.map { |field| render_form_field(field) }.join("\n")
+      action_url = not_pressed.form_submissions_path(form_slug: form.slug)
+      token = respond_to?(:form_authenticity_token) ? form_authenticity_token : ""
+      token_field = token.present? ? %(\n<input type="hidden" name="authenticity_token" value="#{np_escape(token)}">) : ""
+
+      %(<form action="#{action_url}" method="post" class="np-public-form">#{token_field}
+#{fields_html}
+<div class="np-form-submit"><input type="submit" value="Submit" class="np-form-submit-btn"></div>
+</form>).html_safe
+    end
+
+    private
+
+    def render_form_field(field)
+      input_html = case field.field_type.to_s
+                   when "text", "email", "number", "phone", "url", "date"
+                     input_type = field.field_type_phone? ? "tel" : field.field_type.to_s
+                     %(<input type="#{input_type}" name="submission[#{form_field_param_name(field)}]" id="#{form_field_id(field)}" class="np-form-input" placeholder="#{np_escape(field.placeholder.to_s)}"#{required_attr(field)}>)
+                   when "textarea"
+                     %(<textarea name="submission[#{form_field_param_name(field)}]" id="#{form_field_id(field)}" class="np-form-input" placeholder="#{np_escape(field.placeholder.to_s)}" rows="4"#{required_attr(field)}></textarea>)
+                   when "select"
+                     options = parse_options(field.options)
+                     opts_html = %(<option value="">Select...</option>) + options.map { |o| %(<option value="#{np_escape(o)}">#{np_escape(o)}</option>) }.join
+                     %(<select name="submission[#{form_field_param_name(field)}]" id="#{form_field_id(field)}" class="np-form-input"#{required_attr(field)}>#{opts_html}</select>)
+                   when "radio"
+                     options = parse_options(field.options)
+                     options.map { |o|
+                       %(<label class="np-form-radio-label"><input type="radio" name="submission[#{form_field_param_name(field)}]" value="#{np_escape(o)}"#{required_attr(field)}> #{np_escape(o)}</label>)
+                     }.join("\n")
+                   when "checkbox"
+                     options = parse_options(field.options)
+                     if options.any?
+                       options.map { |o|
+                         %(<label class="np-form-checkbox-label"><input type="checkbox" name="submission[#{form_field_param_name(field)}][]" value="#{np_escape(o)}"> #{np_escape(o)}</label>)
+                       }.join("\n")
+                     else
+                       %(<input type="checkbox" name="submission[#{form_field_param_name(field)}]" id="#{form_field_id(field)}" value="1"#{required_attr(field)}>)
+                     end
+                   when "file_upload"
+                     %(<input type="file" name="submission[#{form_field_param_name(field)}]" id="#{form_field_id(field)}" class="np-form-input"#{required_attr(field)}>)
+                   else
+                     %(<input type="text" name="submission[#{form_field_param_name(field)}]" id="#{form_field_id(field)}" class="np-form-input"#{required_attr(field)}>)
+                   end
+
+      %(<div class="np-form-field">
+<label class="np-form-label" for="#{form_field_id(field)}">#{np_escape(field.label)}#{" *" if field.required?}</label>
+#{input_html}
+</div>)
+    end
+
+    def form_field_param_name(field)
+      np_escape(field.label.parameterize(separator: "_"))
+    end
+
+    def form_field_id(field)
+      "field_#{field.id}"
+    end
+
+    def required_attr(field)
+      field.required? ? ' required="required"' : ""
+    end
+
+    def parse_options(options_string)
+      return [] if options_string.blank?
+
+      options_string.split("\n").map(&:strip).reject(&:blank?)
+    end
+
+    def np_escape(text)
+      ERB::Util.html_escape(text)
+    end
+  end
+end

data/app/helpers/not_pressed/media_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module MediaHelper
+    def media_url(media_attachment, variant: nil)
+      return nil if media_attachment.nil? || !media_attachment.file.attached?
+
+      if variant
+        variant_obj = media_attachment.send(variant)
+        return nil unless variant_obj
+
+        url_for(variant_obj)
+      else
+        url_for(media_attachment.file)
+      end
+    end
+
+    def media_image_tag(media_attachment, variant: nil, **options)
+      return nil if media_attachment.nil? || !media_attachment.image?
+
+      src = media_url(media_attachment, variant: variant)
+      return nil unless src
+
+      options[:alt] ||= media_attachment.alt_text
+      tag.img(src: src, **options)
+    end
+  end
+end

data/app/helpers/not_pressed/seo_helper.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module SeoHelper
+    def seo_meta_tags(page, request = nil)
+      return "".html_safe if page.nil?
+
+      tags = []
+      separator = NotPressed.configuration.seo_title_separator
+      site_name = NotPressed.configuration.site_name
+
+      # Title
+      title_text = page.meta_title_or_title
+      full_title = site_name.present? ? "#{title_text}#{separator}#{site_name}" : title_text
+      tags << content_tag(:title, full_title)
+
+      # Meta description
+      if page.meta_description.present?
+        tags << tag(:meta, name: "description", content: page.meta_description)
+      end
+
+      # Robots
+      robots = page.meta_robots_tag
+      if robots.present?
+        tags << tag(:meta, name: "robots", content: robots)
+      end
+
+      # Canonical URL
+      if request
+        tags << tag(:link, rel: "canonical", href: page.effective_canonical_url(request))
+      end
+
+      # Open Graph tags
+      tags << tag(:meta, property: "og:title", content: title_text)
+
+      if page.meta_description.present?
+        tags << tag(:meta, property: "og:description", content: page.meta_description)
+      end
+
+      if page.og_image_url.present?
+        tags << tag(:meta, property: "og:image", content: page.og_image_url)
+      end
+
+      if request
+        tags << tag(:meta, property: "og:url", content: page.effective_canonical_url(request))
+      end
+
+      tags << tag(:meta, property: "og:type", content: page.og_type) if page.og_type.present?
+
+      if site_name.present?
+        tags << tag(:meta, property: "og:site_name", content: site_name)
+      end
+
+      # Twitter Card tags
+      tags << tag(:meta, name: "twitter:card", content: page.twitter_card) if page.twitter_card.present?
+      tags << tag(:meta, name: "twitter:title", content: title_text)
+
+      if page.meta_description.present?
+        tags << tag(:meta, name: "twitter:description", content: page.meta_description)
+      end
+
+      if page.og_image_url.present?
+        tags << tag(:meta, name: "twitter:image", content: page.og_image_url)
+      end
+
+      safe_join(tags, "\n")
+    end
+  end
+end

data/app/helpers/not_pressed/theme_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module ThemeHelper
+    def theme_stylesheet_tag
+      theme = NotPressed::ThemeRegistry.active
+      return unless theme&.theme_stylesheet
+
+      stylesheet_link_tag theme.theme_stylesheet, media: "all"
+    end
+
+    def theme_color_overrides
+      theme = NotPressed::ThemeRegistry.active
+      return unless theme
+
+      colors = theme.theme_color_scheme
+      return if colors.empty?
+
+      overrides = colors.map do |color|
+        setting_key = "theme.#{theme.plugin_name}.color_#{color[:key]}"
+        value = begin
+          NotPressed::Setting.get(setting_key)
+        rescue ActiveRecord::StatementInvalid, ActiveRecord::NoDatabaseError
+          nil
+        end
+        value ||= color[:default]
+        "  --np-color-#{color[:key]}: #{value};"
+      end
+
+      tag.style(":root {\n#{overrides.join("\n")}\n}".html_safe)
+    end
+
+    def active_theme_class
+      theme = NotPressed::ThemeRegistry.active
+      if theme
+        "np-theme-#{theme.plugin_name.to_s.parameterize}"
+      else
+        "np-theme-default"
+      end
+    end
+  end
+end

data/app/mailers/not_pressed/application_mailer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "action_mailer"
+
+module NotPressed
+  class ApplicationMailer < ::ActionMailer::Base
+    default from: "noreply@example.com"
+    layout false
+  end
+end

data/app/mailers/not_pressed/form_mailer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class FormMailer < ApplicationMailer
+    def submission_notification(form_submission)
+      @form_submission = form_submission
+      @form = form_submission.form
+
+      mail(
+        to: @form.email_recipient,
+        subject: "New submission: #{@form.name}"
+      )
+    end
+  end
+end

data/app/models/concerns/not_pressed/sluggable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Sluggable
+    extend ActiveSupport::Concern
+
+    included do
+      validates :slug, presence: true,
+                       uniqueness: true,
+                       format: { with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/, message: "must be lowercase alphanumeric with hyphens" }
+
+      before_validation :generate_slug, on: :create
+    end
+
+    private
+
+    def generate_slug
+      return if slug.present?
+
+      source = slug_source_attribute
+      return if source.blank?
+
+      base_slug = source.encode("UTF-8").parameterize
+      candidate = base_slug
+      counter = 2
+
+      while self.class.where(slug: candidate).exists?
+        candidate = "#{base_slug}-#{counter}"
+        counter += 1
+      end
+
+      self.slug = candidate
+    end
+
+    def slug_source_attribute
+      if respond_to?(:title)
+        title
+      elsif respond_to?(:name)
+        name
+      end
+    end
+  end
+end

data/app/models/not_pressed/category.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class Category < ActiveRecord::Base
+    self.table_name = "not_pressed_categories"
+
+    include NotPressed::Sluggable
+
+    has_many :pages, class_name: "NotPressed::Page", foreign_key: :category_id,
+                     dependent: :nullify, inverse_of: :category
+
+    validates :name, presence: true, uniqueness: true
+
+    scope :ordered, -> { order(:name) }
+  end
+end

data/app/models/not_pressed/content_block.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class ContentBlock < ActiveRecord::Base
+    self.table_name = "not_pressed_content_blocks"
+
+    BUILT_IN_TYPES = %w[text heading image video code quote divider html form].freeze
+
+    mattr_accessor :custom_types, default: []
+
+    belongs_to :page, class_name: "NotPressed::Page", inverse_of: :content_blocks
+
+    validates :block_type, presence: true,
+                           inclusion: { in: ->(_) { NotPressed::ContentBlock.registered_types } }
+    validates :position, presence: true,
+                         numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+    scope :ordered, -> { order(position: :asc) }
+
+    def self.register_type(type_name)
+      custom_types << type_name.to_s unless custom_types.include?(type_name.to_s)
+    end
+
+    def self.registered_types
+      BUILT_IN_TYPES + custom_types
+    end
+
+    def self.default_content_for(block_type)
+      custom = NotPressed::Rendering::RendererRegistry.default_content(block_type)
+      return custom if custom
+
+      case block_type.to_s
+      when "text" then { "body" => "" }
+      when "heading" then { "text" => "", "level" => 2 }
+      when "image" then { "url" => "", "alt" => "", "caption" => "" }
+      when "video" then { "url" => "", "caption" => "" }
+      when "code" then { "code" => "", "language" => "" }
+      when "quote" then { "text" => "", "attribution" => "" }
+      when "divider" then {}
+      when "html" then { "markup" => "" }
+      when "form" then { "form_id" => nil }
+      else {}
+      end
+    end
+  end
+end

data/app/models/not_pressed/form.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class Form < ActiveRecord::Base
+    self.table_name = "not_pressed_forms"
+
+    has_many :form_fields, class_name: "NotPressed::FormField",
+                           foreign_key: :form_id,
+                           dependent: :destroy,
+                           inverse_of: :form do
+      def ordered
+        order(:position)
+      end
+    end
+    accepts_nested_attributes_for :form_fields, allow_destroy: true
+    has_many :form_submissions, class_name: "NotPressed::FormSubmission",
+                                foreign_key: :form_id,
+                                dependent: :destroy,
+                                inverse_of: :form
+
+    # Hook system callbacks
+    after_create { NotPressed::Hooks.fire(:after_form_create, self) }
+    after_save { NotPressed::Hooks.fire(:after_form_save, self) }
+
+    enum :status, { draft: 0, active: 1, archived: 2 }, prefix: true
+
+    validates :name, presence: true
+    validates :slug, presence: true,
+                     uniqueness: true,
+                     format: { with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/, message: "must be lowercase alphanumeric with hyphens" }
+
+    before_validation :generate_slug, on: :create
+
+    scope :active, -> { where(status: :active) }
+    scope :ordered, -> { order(:name) }
+
+    private
+
+    def generate_slug
+      return if slug.present?
+      return if name.blank?
+
+      base_slug = name.encode("UTF-8").parameterize
+      candidate = base_slug
+      counter = 2
+
+      while self.class.where(slug: candidate).exists?
+        candidate = "#{base_slug}-#{counter}"
+        counter += 1
+      end
+
+      self.slug = candidate
+    end
+  end
+end

data/app/models/not_pressed/form_field.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class FormField < ActiveRecord::Base
+    self.table_name = "not_pressed_form_fields"
+
+    belongs_to :form, class_name: "NotPressed::Form", counter_cache: false, inverse_of: :form_fields
+
+    enum :field_type, {
+      text: 0, email: 1, textarea: 2, select: 3, checkbox: 4,
+      radio: 5, number: 6, phone: 7, url: 8, date: 9, file_upload: 10
+    }, prefix: true
+
+    validates :label, presence: true
+    validates :field_type, presence: true
+
+    scope :ordered, -> { order(:position) }
+
+    def has_options?
+      field_type_select? || field_type_radio? || field_type_checkbox?
+    end
+  end
+end

data/app/models/not_pressed/form_submission.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class FormSubmission < ActiveRecord::Base
+    self.table_name = "not_pressed_form_submissions"
+
+    belongs_to :form, class_name: "NotPressed::Form", counter_cache: :submissions_count, inverse_of: :form_submissions
+
+    # Hook system callbacks
+    after_create { NotPressed::Hooks.fire(:after_form_submit, self.form, self) }
+
+    validates :data, presence: true
+    validates :submitted_at, presence: true
+
+    before_validation -> { self.submitted_at ||= Time.current }, on: :create
+
+    scope :recent, -> { order(submitted_at: :desc) }
+  end
+end

data/app/models/not_pressed/media_attachment.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class MediaAttachment < ActiveRecord::Base
+    self.table_name = "not_pressed_media_attachments"
+
+    IMAGE_CONTENT_TYPES = %w[image/jpeg image/png image/gif image/webp image/svg+xml].freeze
+
+    has_one_attached :file
+
+    # Hook system callbacks
+    after_create { NotPressed::Hooks.fire(:after_media_upload, self) }
+    after_destroy { NotPressed::Hooks.fire(:after_media_destroy, self) }
+
+    validate :file_attached, on: :create
+
+    before_save :extract_file_metadata, if: -> { file.attached? }
+
+    scope :images, -> { where(content_type: IMAGE_CONTENT_TYPES) }
+    scope :documents, -> { where.not(content_type: IMAGE_CONTENT_TYPES) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def image?
+      content_type.in?(IMAGE_CONTENT_TYPES)
+    end
+
+    def thumbnail
+      return nil unless image?
+
+      file.variant(resize_to_limit: [200, 200])
+    end
+
+    def small
+      return nil unless image?
+
+      file.variant(resize_to_limit: [400, 400])
+    end
+
+    def medium
+      return nil unless image?
+
+      file.variant(resize_to_limit: [800, 800])
+    end
+
+    def large
+      return nil unless image?
+
+      file.variant(resize_to_limit: [1200, 1200])
+    end
+
+    def hero
+      return nil unless image?
+
+      file.variant(resize_to_limit: [1920, 1080])
+    end
+
+    private
+
+    def file_attached
+      errors.add(:file, "must be attached") unless file.attached?
+    end
+
+    def extract_file_metadata
+      self.content_type = file.blob.content_type
+      self.file_size = file.blob.byte_size
+    end
+  end
+end